openclaw-cortex-memory 0.1.0-Alpha.1 → 0.1.0-Alpha.10

package/dist/index.js

@@ -46,10 +46,14 @@ 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 archive_store_1 = require("./src/store/archive_store");
+const vector_store_1 = require("./src/store/vector_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 three_stage_deduplicator_1 = require("./src/dedup/three_stage_deduplicator");
+const runtime_env_1 = require("./src/utils/runtime_env");
 const ERROR_CODES = {
     CONNECTION_REFUSED: {
         code: "E001",
@@ -89,6 +93,64 @@ const MAX_OPENCLAW_VERSION = "2027.0.0";
 const defaultConfig = {
     autoSync: true,
     autoReflect: false,
+    autoReflectIntervalMinutes: 30,
+    readFusion: {
+        enabled: true,
+        maxCandidates: 10,
+        authoritative: true,
+        channelWeights: {
+            rules: 1,
+            archive: 1.15,
+            vector: 1.2,
+            graph: 1,
+        },
+        channelTopK: {
+            rules: 8,
+            archive: 20,
+            vector: 20,
+            graph: 12,
+        },
+        minLexicalHits: 1,
+        minSemanticHits: 1,
+        lengthNorm: {
+            enabled: true,
+            pivotChars: 1200,
+            strength: 0.75,
+            minFactor: 0.45,
+        },
+    },
+    vectorChunking: {
+        chunkSize: 600,
+        chunkOverlap: 100,
+    },
+    memoryDecay: {
+        enabled: true,
+        minFloor: 0.15,
+        defaultHalfLifeDays: 90,
+        antiDecay: {
+            enabled: true,
+            maxBoost: 1.6,
+            hitWeight: 0.08,
+            recentWindowDays: 30,
+        },
+        halfLifeByEventType: {
+            issue: 30,
+            fix: 30,
+            action_item: 30,
+            blocker: 30,
+            plan: 60,
+            milestone: 60,
+            follow_up: 60,
+            decision: 120,
+            insight: 120,
+            retrospective: 120,
+            preference: 240,
+            constraint: 240,
+            requirement: 240,
+            dependency: 240,
+            assumption: 240,
+        },
+    },
     enabled: true,
     fallbackToBuiltin: true,
     engineMode: "ts",
@@ -96,6 +158,7 @@ const defaultConfig = {
 let autoSearchCacheBySession = new Map();
 const AUTO_SEARCH_CACHE_TTL = 60000;
 const MAX_AUTO_SEARCH_CACHE_SESSIONS = 200;
+const HOOK_GUARD_TIMEOUT_MS = 2000;
 let config = null;
 let logger;
 let pythonProcess = null;
@@ -150,6 +213,33 @@ function getSessionCachedAutoSearch(sessionId) {
         ageSeconds: Math.floor((Date.now() - cache.timestamp) / 1000),
     };
 }
+function isInternalSession(sessionId) {
+    if (!sessionId)
+        return false;
+    return sessionId.startsWith("slug-generator-") || sessionId.startsWith("fallback:");
+}
+async function runWithTimeout(task, timeoutMs, label) {
+    let timeoutHandle = null;
+    try {
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => resolve(null), timeoutMs);
+        });
+        const result = await Promise.race([task, timeoutPromise]);
+        if (result === null) {
+            logger.warn(`${label} timed out after ${timeoutMs}ms; skipped to protect gateway responsiveness`);
+        }
+        return result;
+    }
+    catch (error) {
+        logger.warn(`${label} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
 function resolveEngine() {
     if (!config) {
         throw new Error("Configuration not loaded");
@@ -164,16 +254,43 @@ function resolveEngine() {
         projectRoot,
         dbPath: config.dbPath,
         logger,
+        embedding: config.embedding,
+        reranker: config.reranker,
+        llm: config.llm,
+        fusion: config.readFusion,
+        memoryDecay: config.memoryDecay,
+    });
+    const vectorStore = (0, vector_store_1.createVectorStore)({
+        memoryRoot,
+        logger,
     });
     const writeStore = (0, write_store_1.createWriteStore)({
         projectRoot,
         dbPath: config.dbPath,
         logger,
+        embedding: config.embedding,
+        vectorChunking: config.vectorChunking,
+        vectorStore,
+    });
+    const deduplicator = (0, three_stage_deduplicator_1.createThreeStageDeduplicator)({
+        memoryRoot,
+        logger,
+    });
+    const archiveStore = (0, archive_store_1.createArchiveStore)({
+        projectRoot,
+        memoryRoot,
+        logger,
+        embedding: config.embedding,
+        vectorChunking: config.vectorChunking,
+        deduplicator,
+        vectorStore,
     });
     const sessionSync = (0, session_sync_1.createSessionSync)({
         projectRoot,
         dbPath: config.dbPath,
         logger,
+        llm: config.llm,
+        archiveStore,
         writeStore,
     });
     const sessionEnd = (0, session_end_1.createSessionEnd)({
@@ -181,6 +298,9 @@ function resolveEngine() {
         dbPath: config.dbPath,
         logger,
         syncMemory: sessionSync.syncMemory,
+        syncDailySummaries: sessionSync.syncDailySummaries,
+        archiveStore,
+        llm: config.llm,
     });
     const ruleStore = (0, rule_store_1.createRuleStore)({
         projectRoot,
@@ -192,14 +312,22 @@ function resolveEngine() {
         dbPath: config.dbPath,
         logger,
         ruleStore,
+        llm: config.llm,
     });
     memoryEngine = (0, ts_engine_1.createTsEngine)({
         readStore,
         writeStore,
+        vectorStore,
+        archiveStore,
         sessionSync,
         sessionEnd,
         reflector,
         memoryRoot,
+        projectRoot,
+        embedding: config.embedding,
+        llm: config.llm,
+        reranker: config.reranker,
+        vectorChunking: config.vectorChunking,
         getCachedAutoSearch: getSessionCachedAutoSearch,
         resolveSessionId: (context, payload) => resolveSessionId(context, payload),
         normalizeIncomingMessage,
@@ -257,6 +385,15 @@ function sanitizeForLogging(obj) {
     }
     return sanitized;
 }
+function logLifecycle(event, details = {}) {
+    const payload = sanitizeForLogging({
+        event,
+        plugin: PLUGIN_ID,
+        ts: new Date().toISOString(),
+        ...details,
+    });
+    logger.info(`[Lifecycle] ${JSON.stringify(payload)}`);
+}
 function asRecord(value) {
     if (typeof value === "object" && value !== null) {
         return value;
@@ -381,7 +518,7 @@ function compareVersions(a, b) {
 }
 async function checkOpenClawVersion() {
     try {
-        const version = process.env.OPENCLAW_VERSION;
+        const version = (0, runtime_env_1.getEnvValue)("OPENCLAW_VERSION");
         if (version) {
             if (compareVersions(version, MIN_OPENCLAW_VERSION) < 0) {
                 throw new Error(`Incompatible OpenClaw version: ${version}. Minimum required: ${MIN_OPENCLAW_VERSION}`);
@@ -415,13 +552,19 @@ function findProjectRoot() {
     throw new Error("Cannot find project root directory");
 }
 function findOpenClawConfig() {
+    const explicitConfigPath = (0, runtime_env_1.getEnvValue)("OPENCLAW_CONFIG_PATH");
+    const stateDir = (0, runtime_env_1.getEnvValue)("OPENCLAW_STATE_DIR");
+    const basePath = (0, runtime_env_1.getEnvValue)("OPENCLAW_BASE_PATH");
+    const homePath = (0, runtime_env_1.getHomeDir)();
     const possiblePaths = [
+        explicitConfigPath,
+        stateDir ? path.join(stateDir, "openclaw.json") : "",
+        basePath ? path.join(basePath, "openclaw.json") : "",
         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"),
+        homePath ? path.join(homePath, ".openclaw", "openclaw.json") : "",
     ];
     for (const p of possiblePaths) {
-        if (fs.existsSync(p)) {
+        if (p && fs.existsSync(p)) {
             return p;
         }
     }
@@ -476,6 +619,8 @@ function startAutoReflectScheduler() {
     if (!config?.autoReflect || autoReflectInterval) {
         return;
     }
+    const intervalMinutes = Math.max(5, Math.floor(config.autoReflectIntervalMinutes ?? 30));
+    const intervalMs = intervalMinutes * 60 * 1000;
     autoReflectInterval = setInterval(() => {
         if (!isEnabled) {
             return;
@@ -492,7 +637,7 @@ function startAutoReflectScheduler() {
         if (marker === lastAutoReflectArchiveMarker) {
             return;
         }
-        if (now - lastAutoReflectRunAt < 5 * 60 * 1000) {
+        if (now - lastAutoReflectRunAt < intervalMs) {
             return;
         }
         resolveEngine().reflectMemory({}, schedulerContext)
@@ -507,7 +652,7 @@ function startAutoReflectScheduler() {
             }
         })
             .catch(error => logger.warn(`Auto-reflect failed: ${String(error)}`));
-    }, 5 * 60 * 1000);
+    }, intervalMs);
 }
 function stopAutoReflectScheduler() {
     if (autoReflectInterval) {
@@ -523,6 +668,12 @@ function validateConfig(cfg) {
     if (!cfg.embedding?.apiKey || !cfg.embedding?.baseURL) {
         errors.push("embedding.apiKey and embedding.baseURL are required. Please configure third-party embedding endpoint credentials.");
     }
+    if (typeof cfg.embedding?.timeoutMs === "number" && (!Number.isFinite(cfg.embedding.timeoutMs) || cfg.embedding.timeoutMs < 1000)) {
+        errors.push("embedding.timeoutMs must be a number >= 1000.");
+    }
+    if (typeof cfg.embedding?.maxRetries === "number" && (!Number.isFinite(cfg.embedding.maxRetries) || cfg.embedding.maxRetries < 1 || cfg.embedding.maxRetries > 8)) {
+        errors.push("embedding.maxRetries must be between 1 and 8.");
+    }
     if (!cfg.llm?.provider || !cfg.llm?.model) {
         errors.push("llm.provider and llm.model are required. Please configure them in openclaw.json");
     }
@@ -535,6 +686,88 @@ function validateConfig(cfg) {
     if (!cfg.reranker?.apiKey || !cfg.reranker?.baseURL) {
         errors.push("reranker.apiKey and reranker.baseURL are required. Please configure third-party reranker endpoint credentials.");
     }
+    if (typeof cfg.autoReflectIntervalMinutes === "number" && (!Number.isFinite(cfg.autoReflectIntervalMinutes) || cfg.autoReflectIntervalMinutes < 5)) {
+        errors.push("autoReflectIntervalMinutes must be a number >= 5.");
+    }
+    if (cfg.readFusion && typeof cfg.readFusion.maxCandidates === "number" && (!Number.isFinite(cfg.readFusion.maxCandidates) || cfg.readFusion.maxCandidates < 2)) {
+        errors.push("readFusion.maxCandidates must be a number >= 2.");
+    }
+    if (cfg.readFusion?.channelWeights) {
+        for (const [key, value] of Object.entries(cfg.readFusion.channelWeights)) {
+            if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+                errors.push(`readFusion.channelWeights.${key} must be a number > 0.`);
+                break;
+            }
+        }
+    }
+    if (cfg.readFusion?.channelTopK) {
+        for (const [key, value] of Object.entries(cfg.readFusion.channelTopK)) {
+            if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+                errors.push(`readFusion.channelTopK.${key} must be a number >= 1.`);
+                break;
+            }
+        }
+    }
+    if (typeof cfg.readFusion?.minLexicalHits === "number" && (!Number.isFinite(cfg.readFusion.minLexicalHits) || cfg.readFusion.minLexicalHits < 0)) {
+        errors.push("readFusion.minLexicalHits must be a number >= 0.");
+    }
+    if (typeof cfg.readFusion?.minSemanticHits === "number" && (!Number.isFinite(cfg.readFusion.minSemanticHits) || cfg.readFusion.minSemanticHits < 0)) {
+        errors.push("readFusion.minSemanticHits must be a number >= 0.");
+    }
+    if (cfg.readFusion?.lengthNorm) {
+        const ln = cfg.readFusion.lengthNorm;
+        if (typeof ln.pivotChars === "number" && (!Number.isFinite(ln.pivotChars) || ln.pivotChars <= 0)) {
+            errors.push("readFusion.lengthNorm.pivotChars must be > 0.");
+        }
+        if (typeof ln.strength === "number" && (!Number.isFinite(ln.strength) || ln.strength <= 0)) {
+            errors.push("readFusion.lengthNorm.strength must be > 0.");
+        }
+        if (typeof ln.minFactor === "number" && (!Number.isFinite(ln.minFactor) || ln.minFactor <= 0 || ln.minFactor > 1)) {
+            errors.push("readFusion.lengthNorm.minFactor must be within (0,1].");
+        }
+    }
+    if (cfg.vectorChunking) {
+        if (typeof cfg.vectorChunking.chunkSize === "number" && (!Number.isFinite(cfg.vectorChunking.chunkSize) || cfg.vectorChunking.chunkSize < 200)) {
+            errors.push("vectorChunking.chunkSize must be >= 200.");
+        }
+        if (typeof cfg.vectorChunking.chunkOverlap === "number" && (!Number.isFinite(cfg.vectorChunking.chunkOverlap) || cfg.vectorChunking.chunkOverlap < 0)) {
+            errors.push("vectorChunking.chunkOverlap must be >= 0.");
+        }
+        if (typeof cfg.vectorChunking.chunkSize === "number" &&
+            typeof cfg.vectorChunking.chunkOverlap === "number" &&
+            cfg.vectorChunking.chunkOverlap >= cfg.vectorChunking.chunkSize) {
+            errors.push("vectorChunking.chunkOverlap must be smaller than chunkSize.");
+        }
+    }
+    if (cfg.memoryDecay) {
+        if (typeof cfg.memoryDecay.minFloor === "number" && (!Number.isFinite(cfg.memoryDecay.minFloor) || cfg.memoryDecay.minFloor < 0 || cfg.memoryDecay.minFloor > 1)) {
+            errors.push("memoryDecay.minFloor must be within [0,1].");
+        }
+        if (typeof cfg.memoryDecay.defaultHalfLifeDays === "number" && (!Number.isFinite(cfg.memoryDecay.defaultHalfLifeDays) || cfg.memoryDecay.defaultHalfLifeDays <= 0)) {
+            errors.push("memoryDecay.defaultHalfLifeDays must be > 0.");
+        }
+        const mapping = cfg.memoryDecay.halfLifeByEventType;
+        if (mapping && typeof mapping === "object") {
+            for (const [key, value] of Object.entries(mapping)) {
+                if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+                    errors.push(`memoryDecay.halfLifeByEventType.${key} must be > 0.`);
+                    break;
+                }
+            }
+        }
+        const anti = cfg.memoryDecay.antiDecay;
+        if (anti) {
+            if (typeof anti.maxBoost === "number" && (!Number.isFinite(anti.maxBoost) || anti.maxBoost < 1)) {
+                errors.push("memoryDecay.antiDecay.maxBoost must be >= 1.");
+            }
+            if (typeof anti.hitWeight === "number" && (!Number.isFinite(anti.hitWeight) || anti.hitWeight < 0)) {
+                errors.push("memoryDecay.antiDecay.hitWeight must be >= 0.");
+            }
+            if (typeof anti.recentWindowDays === "number" && (!Number.isFinite(anti.recentWindowDays) || anti.recentWindowDays <= 0)) {
+                errors.push("memoryDecay.antiDecay.recentWindowDays must be > 0.");
+            }
+        }
+    }
     return errors;
 }
 function getApiHostAndPort() {
@@ -720,14 +953,14 @@ async function startPythonServiceInternal() {
     }
     logger.info("Starting Cortex Memory Python service...");
     const env = {
-        ...process.env,
+        ...(0, runtime_env_1.getProcessEnvCopy)(),
         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"),
+        CORTEX_MEMORY_DB_PATH: config.dbPath || path.join((0, runtime_env_1.getHomeDir)(), ".openclaw", "agents", "main", "lancedb_store"),
     };
     if (config.embedding.apiKey) {
         env.CORTEX_MEMORY_EMBEDDING_API_KEY = config.embedding.apiKey;
@@ -870,7 +1103,7 @@ function stopPythonService() {
     stopPythonServiceAsync();
 }
 function getBaseUrl() {
-    return config?.apiUrl ?? "http://127.0.0.1:8765";
+    return config?.apiUrl ?? "http://localhost:8765";
 }
 async function waitForService(maxAttempts = 30) {
     const apiUrl = getBaseUrl();
@@ -1365,10 +1598,18 @@ async function onTimerPythonHandler(payload, _context) {
     }
 }
 async function onMessageHandler(payload, context) {
-    await resolveEngine().onMessage(payload, context);
+    const sessionId = resolveSessionId(context, payload);
+    if (isInternalSession(sessionId)) {
+        return;
+    }
+    await runWithTimeout(resolveEngine().onMessage(payload, context), HOOK_GUARD_TIMEOUT_MS, "onMessage hook");
 }
 async function onSessionEndHandler(payload, context) {
-    await resolveEngine().onSessionEnd(payload, context);
+    const sessionId = resolveSessionId(context, payload);
+    if (isInternalSession(sessionId)) {
+        return;
+    }
+    await runWithTimeout(resolveEngine().onSessionEnd(payload, context), HOOK_GUARD_TIMEOUT_MS, "onSessionEnd hook");
 }
 async function onTimerHandler(payload, context) {
     await resolveEngine().onTimer(payload, context);
@@ -1497,6 +1738,26 @@ function registerTools() {
                 return resolveEngine().syncMemory(args, params.context);
             },
         },
+        {
+            name: "backfill_embeddings",
+            description: "Backfill missing embeddings for active/archive records",
+            parameters: {
+                type: "object",
+                properties: {
+                    layer: { type: "string", enum: ["active", "archive", "all"], description: "Target layer to backfill" },
+                    batch_size: { type: "integer", description: "Batch size per processing window" },
+                    max_retries: { type: "integer", description: "Max retry count for failed records" },
+                    retry_failed_only: { type: "boolean", description: "Only retry failed records" },
+                    rebuild_mode: { type: "string", enum: ["incremental", "vector_only", "full"], description: "Rebuild mode" },
+                },
+                required: [],
+                additionalProperties: false,
+            },
+            execute: async (params) => {
+                const args = params.args || params;
+                return resolveEngine().backfillEmbeddings(args, params.context);
+            },
+        },
         {
             name: "delete_memory",
             description: "Delete a memory by ID",
@@ -1529,10 +1790,39 @@ function registerTools() {
         },
     ];
     for (const tool of tools) {
-        api.registerTool(tool);
+        registerToolCompat(tool);
         registeredTools.push(tool.name);
     }
 }
+function registerToolCompat(tool) {
+    if (!api)
+        return;
+    const execute = async (params) => tool.execute({
+        args: params?.args || {},
+        context: params.context,
+    });
+    const handler = async (...params) => {
+        const first = params[0];
+        const second = params[1];
+        if (first && typeof first === "object" && "context" in first) {
+            return execute({
+                args: first.args || {},
+                context: first.context,
+            });
+        }
+        return execute({
+            args: first || {},
+            context: (second || {}),
+        });
+    };
+    api.registerTool({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+        execute,
+        handler,
+    });
+}
 function unregisterTools() {
     if (!api || !api.unregisterTool)
         return;
@@ -1637,6 +1927,7 @@ async function enable() {
         return;
     }
     logger.info("Enabling Cortex Memory plugin...");
+    logLifecycle("enable_start");
     try {
         unregisterFallbackTools();
         if (shouldUsePythonRuntime()) {
@@ -1648,10 +1939,12 @@ async function enable() {
         registerHooks();
         startAutoReflectScheduler();
         logger.info("Cortex Memory plugin enabled successfully");
+        logLifecycle("enable_success", { registeredTools: registeredTools.length, registeredHooks: registeredHooks.length });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         logger.error(`Failed to enable Cortex Memory plugin: ${message}`);
+        logLifecycle("enable_failed", { error: message });
         throw error;
     }
 }
@@ -1661,6 +1954,7 @@ async function disable() {
         return;
     }
     logger.info("Disabling Cortex Memory plugin...");
+    logLifecycle("disable_start");
     unregisterHooks();
     unregisterTools();
     unregisterFallbackTools();
@@ -1673,13 +1967,15 @@ async function disable() {
     if (config?.fallbackToBuiltin && builtinMemory) {
         logger.info("Falling back to OpenClaw builtin memory system");
         registerFallbackTools();
+        logLifecycle("fallback_enabled", { fallbackTools: registeredFallbackTools.length });
     }
     logger.info("Cortex Memory plugin disabled successfully");
+    logLifecycle("disable_success", { fallbackEnabled: registeredFallbackTools.length > 0 });
 }
 function registerFallbackTools() {
     if (!api || !builtinMemory)
         return;
-    api.registerTool({
+    registerToolCompat({
         name: "search_memory",
         description: "Search memory (using builtin system - Cortex Memory disabled)",
         parameters: {
@@ -1691,10 +1987,10 @@ function registerFallbackTools() {
             required: ["query"],
             additionalProperties: false,
         },
-        execute: async ({ args, context }) => searchMemoryWithFallback(args, context),
+        execute: async ({ args, context }) => searchMemoryWithFallback((args || {}), context),
     });
     registeredFallbackTools.push("search_memory");
-    api.registerTool({
+    registerToolCompat({
         name: "store_event",
         description: "Store event (using builtin system - Cortex Memory disabled)",
         parameters: {
@@ -1705,10 +2001,10 @@ function registerFallbackTools() {
             required: ["summary"],
             additionalProperties: false,
         },
-        execute: async ({ args, context }) => storeEventWithFallback(args, context),
+        execute: async ({ args, context }) => storeEventWithFallback((args || {}), context),
     });
     registeredFallbackTools.push("store_event");
-    api.registerTool({
+    registerToolCompat({
         name: "cortex_memory_status",
         description: "Get the current status of the Cortex Memory plugin",
         parameters: {
@@ -1717,7 +2013,7 @@ function registerFallbackTools() {
             required: [],
             additionalProperties: false,
         },
-        execute: async ({ args, context }) => getPluginStatus(args, context),
+        execute: async ({ args, context }) => getPluginStatus(args || {}, context),
     });
     registeredFallbackTools.push("cortex_memory_status");
 }
@@ -1742,6 +2038,7 @@ function getStatus() {
 }
 async function unregister() {
     logger.info("Unregistering Cortex Memory plugin...");
+    logLifecycle("unregister_start");
     stopConfigWatcher();
     stopAutoReflectScheduler();
     unregisterHooks();
@@ -1768,6 +2065,7 @@ async function unregister() {
     stopAutoReflectScheduler();
     configPath = null;
     logger.info("Cortex Memory plugin unregistered successfully");
+    logLifecycle("unregister_success");
 }
 function register(pluginApi, userConfig) {
     if (isInitializing || isRegistered) {
@@ -1803,9 +2101,41 @@ function register(pluginApi, userConfig) {
         dbPath: effectiveConfig.dbPath,
         autoSync: effectiveConfig.autoSync ?? defaultConfig.autoSync,
         autoReflect: effectiveConfig.autoReflect ?? defaultConfig.autoReflect,
+        autoReflectIntervalMinutes: effectiveConfig.autoReflectIntervalMinutes ?? defaultConfig.autoReflectIntervalMinutes,
+        readFusion: {
+            enabled: effectiveConfig.readFusion?.enabled ?? defaultConfig.readFusion?.enabled,
+            maxCandidates: effectiveConfig.readFusion?.maxCandidates ?? defaultConfig.readFusion?.maxCandidates,
+            authoritative: effectiveConfig.readFusion?.authoritative ?? defaultConfig.readFusion?.authoritative,
+            channelWeights: effectiveConfig.readFusion?.channelWeights ?? defaultConfig.readFusion?.channelWeights,
+            channelTopK: effectiveConfig.readFusion?.channelTopK ?? defaultConfig.readFusion?.channelTopK,
+            minLexicalHits: effectiveConfig.readFusion?.minLexicalHits ?? defaultConfig.readFusion?.minLexicalHits,
+            minSemanticHits: effectiveConfig.readFusion?.minSemanticHits ?? defaultConfig.readFusion?.minSemanticHits,
+            lengthNorm: {
+                enabled: effectiveConfig.readFusion?.lengthNorm?.enabled ?? defaultConfig.readFusion?.lengthNorm?.enabled,
+                pivotChars: effectiveConfig.readFusion?.lengthNorm?.pivotChars ?? defaultConfig.readFusion?.lengthNorm?.pivotChars,
+                strength: effectiveConfig.readFusion?.lengthNorm?.strength ?? defaultConfig.readFusion?.lengthNorm?.strength,
+                minFactor: effectiveConfig.readFusion?.lengthNorm?.minFactor ?? defaultConfig.readFusion?.lengthNorm?.minFactor,
+            },
+        },
+        vectorChunking: {
+            chunkSize: effectiveConfig.vectorChunking?.chunkSize ?? defaultConfig.vectorChunking?.chunkSize,
+            chunkOverlap: effectiveConfig.vectorChunking?.chunkOverlap ?? defaultConfig.vectorChunking?.chunkOverlap,
+        },
+        memoryDecay: {
+            enabled: effectiveConfig.memoryDecay?.enabled ?? defaultConfig.memoryDecay?.enabled,
+            minFloor: effectiveConfig.memoryDecay?.minFloor ?? defaultConfig.memoryDecay?.minFloor,
+            defaultHalfLifeDays: effectiveConfig.memoryDecay?.defaultHalfLifeDays ?? defaultConfig.memoryDecay?.defaultHalfLifeDays,
+            halfLifeByEventType: effectiveConfig.memoryDecay?.halfLifeByEventType ?? defaultConfig.memoryDecay?.halfLifeByEventType,
+            antiDecay: {
+                enabled: effectiveConfig.memoryDecay?.antiDecay?.enabled ?? defaultConfig.memoryDecay?.antiDecay?.enabled,
+                maxBoost: effectiveConfig.memoryDecay?.antiDecay?.maxBoost ?? defaultConfig.memoryDecay?.antiDecay?.maxBoost,
+                hitWeight: effectiveConfig.memoryDecay?.antiDecay?.hitWeight ?? defaultConfig.memoryDecay?.antiDecay?.hitWeight,
+                recentWindowDays: effectiveConfig.memoryDecay?.antiDecay?.recentWindowDays ?? defaultConfig.memoryDecay?.antiDecay?.recentWindowDays,
+            },
+        },
         enabled: effectiveConfig.enabled ?? defaultConfig.enabled,
         fallbackToBuiltin: effectiveConfig.fallbackToBuiltin ?? defaultConfig.fallbackToBuiltin,
-        apiUrl: effectiveConfig.apiUrl ?? "http://127.0.0.1:8765",
+        apiUrl: effectiveConfig.apiUrl ?? "http://localhost:8765",
         engineMode: "ts",
     };
     memoryEngine = null;
@@ -1840,6 +2170,11 @@ function register(pluginApi, userConfig) {
     isRegistered = true;
     logger.info("Cortex Memory plugin registered successfully");
     logger.info(`Cortex Memory engine mode: ${resolveEngine().mode}`);
+    logLifecycle("register_success", {
+        engineMode: config.engineMode,
+        enabled: isEnabled,
+        hasBuiltinFallback: Boolean(builtinMemory),
+    });
     if (isEnabled) {
         registerTools();
         registerHooks();
@@ -1853,11 +2188,13 @@ function register(pluginApi, userConfig) {
                 logger.info("Falling back to builtin memory");
                 isEnabled = false;
                 registerFallbackTools();
+                logLifecycle("fallback_after_init_error", { fallbackTools: registeredFallbackTools.length, error: message });
             }
         });
     }
     else if (config?.fallbackToBuiltin && builtinMemory) {
         registerFallbackTools();
+        logLifecycle("fallback_registered_on_start", { fallbackTools: registeredFallbackTools.length });
     }
 }
 async function initializeAsync() {