memorylake-openclaw 1.1.2 → 1.1.4

package/lib/cli/register-cli.ts

@@ -1,134 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import type { PluginContext } from "../plugin-context";
-import type { MemoryLakeConfig, UploadFn } from "../types";
-import { getProvider } from "../provider";
-import { buildSearchOptions } from "../utils/builders";
-import { readJson5ConfigFile } from "../utils/config-parser";
-
-export function registerCli(pctx: PluginContext, cfg: MemoryLakeConfig): void {
-  const { api, resolveConfig } = pctx;
-  const provider = getProvider(cfg);
-
-  api.registerCli(
-    ({ program }) => {
-      const memorylake = program
-        .command("memorylake")
-        .description("MemoryLake memory plugin commands");
-
-      memorylake
-        .command("search")
-        .description("Search memories in MemoryLake")
-        .argument("<query>", "Search query")
-        .option("--limit <n>", "Max results", String(cfg.topK))
-        .action(async (query: string, opts: { limit: string }) => {
-          try {
-            const limit = parseInt(opts.limit, 10);
-            const results = await provider.search(
-              query,
-              buildSearchOptions(cfg, undefined, limit),
-            );
-
-            if (!results.length) {
-              console.log("No memories found.");
-              return;
-            }
-
-            const output = results.map((r) => ({
-              id: r.id,
-              content: r.content,
-              user_id: r.user_id,
-              created_at: r.created_at,
-            }));
-            console.log(JSON.stringify(output, null, 2));
-          } catch (err) {
-            console.error(`Search failed: ${String(err)}`);
-          }
-        });
-
-      memorylake
-        .command("upload")
-        .description("Upload files or directories to MemoryLake")
-        .argument("<path>", "File or directory path to upload")
-        .option("--agent <id>", "Agent ID (resolves workspace and per-agent projectId)")
-        .option("--project-id <id>", "Override project ID (takes precedence over --agent)")
-        .action(async (targetPath: string, opts: { agent?: string; projectId?: string }) => {
-          // Resolve effective config: --project-id > agent workspace config > global config
-          let effectiveCfg = cfg;
-          if (opts.agent) {
-            try {
-              const openclawPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
-              const openclaw = readJson5ConfigFile(openclawPath) as any;
-              const agents = openclaw?.agents;
-              const agentEntry = agents?.list?.find((a: any) => a.id === opts.agent);
-              const workspace = agentEntry?.workspace || agents?.defaults?.workspace;
-              if (workspace) {
-                effectiveCfg = resolveConfig({ workspaceDir: workspace });
-              } else {
-                console.warn(`Warning: no workspace found for agent "${opts.agent}", using global config.`);
-              }
-            } catch (err) {
-              console.warn(`Warning: failed to resolve agent config: ${String(err)}, using global config.`);
-            }
-          }
-          const effectiveProjectId = opts.projectId || effectiveCfg.projectId;
-          if (!effectiveProjectId) {
-            console.error("No project ID configured. Use --project-id or set up agent/workspace config.");
-            return;
-          }
-          if (!effectiveCfg.host || !effectiveCfg.apiKey) {
-            console.error("Missing host or apiKey in config. Check your MemoryLake configuration.");
-            return;
-          }
-
-          // Lazy import upload.mjs (use uploadAuto to support archives)
-          let uploadFn: UploadFn;
-          try {
-            const uploadModule = await import(
-              /* webpackIgnore: true */
-              new URL("../../skills/memorylake-upload/scripts/upload.mjs", import.meta.url).href
-            );
-            uploadFn = uploadModule.uploadAuto;
-          } catch (err) {
-            console.error(`Failed to load upload module: ${String(err)}`);
-            return;
-          }
-
-          const absPath = path.resolve(targetPath);
-
-          try {
-            await uploadFn({
-              host: effectiveCfg.host,
-              apiKey: effectiveCfg.apiKey,
-              projectId: effectiveProjectId,
-              filePath: absPath,
-              fileName: path.basename(absPath),
-            });
-          } catch (err) {
-            console.error(`Upload failed: ${String(err)}`);
-          }
-        });
-
-      memorylake
-        .command("stats")
-        .description("Show memory statistics from MemoryLake")
-        .action(async () => {
-          try {
-            const memories = await provider.getAll({
-              user_id: cfg.userId,
-            });
-            console.log(`User: ${cfg.userId}`);
-            console.log(
-              `Total memories: ${Array.isArray(memories) ? memories.length : "unknown"}`,
-            );
-            console.log(
-              `Auto-recall: ${cfg.autoRecall}, Auto-capture: ${cfg.autoCapture}`,
-            );
-          } catch (err) {
-            console.error(`Stats failed: ${String(err)}`);
-          }
-        });
-    },
-    { commands: ["memorylake"] },
-  );
-}

package/lib/config.ts

@@ -1,105 +0,0 @@
-import type { MemoryLakeConfig } from "./types";
-import { DEFAULT_USER_ID } from "./types";
-
-// ============================================================================
-// Config Schema
-// ============================================================================
-
-export const ALLOWED_KEYS = [
-  "host",
-  "apiKey",
-  "projectId",
-  "userId",
-  "autoCapture",
-  "autoRecall",
-  "autoUpload",
-  "searchThreshold",
-  "topK",
-  "rerank",
-  "webSearchIncludeDomains",
-  "webSearchExcludeDomains",
-  "webSearchCountry",
-  "webSearchTimezone",
-];
-
-function assertAllowedKeys(
-  value: Record<string, unknown>,
-  allowed: string[],
-  label: string,
-) {
-  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
-  if (unknown.length === 0) return;
-  throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`);
-}
-
-function parseOptionalStringArray(
-  value: unknown,
-  label: string,
-): string[] | undefined {
-  if (value == null) return undefined;
-  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
-    throw new Error(`${label} must be an array of strings`);
-  }
-  return value;
-}
-
-function parseOptionalString(
-  value: unknown,
-  label: string,
-): string | undefined {
-  if (value == null) return undefined;
-  if (typeof value !== "string") {
-    throw new Error(`${label} must be a string`);
-  }
-  return value;
-}
-
-export const memoryLakeConfigSchema = {
-  parse(value: unknown): MemoryLakeConfig {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error("memorylake-openclaw config required");
-    }
-    const cfg = value as Record<string, unknown>;
-    assertAllowedKeys(cfg, ALLOWED_KEYS, "memorylake-openclaw config");
-
-    if (typeof cfg.apiKey !== "string" || !cfg.apiKey) {
-      throw new Error("apiKey is required");
-    }
-    if (typeof cfg.projectId !== "string" || !cfg.projectId) {
-      throw new Error("projectId is required");
-    }
-
-    return {
-      host:
-        typeof cfg.host === "string" && cfg.host
-          ? cfg.host
-          : "https://app.memorylake.ai",
-      apiKey: cfg.apiKey as string,
-      projectId: cfg.projectId as string,
-      userId: DEFAULT_USER_ID,
-      autoCapture: cfg.autoCapture !== false,
-      autoRecall: cfg.autoRecall !== false,
-      autoUpload: cfg.autoUpload !== false,
-      searchThreshold:
-        typeof cfg.searchThreshold === "number" ? cfg.searchThreshold : 0.3,
-      topK: typeof cfg.topK === "number" ? cfg.topK : 5,
-      rerank: cfg.rerank !== false,
-      webSearchIncludeDomains: parseOptionalStringArray(
-        cfg.webSearchIncludeDomains,
-        "webSearchIncludeDomains",
-      ),
-      webSearchExcludeDomains: parseOptionalStringArray(
-        cfg.webSearchExcludeDomains,
-        "webSearchExcludeDomains",
-      ),
-      webSearchCountry: parseOptionalString(
-        cfg.webSearchCountry,
-        "webSearchCountry",
-      ),
-      webSearchTimezone: parseOptionalString(
-        cfg.webSearchTimezone,
-        "webSearchTimezone",
-      ),
-    };
-  },
-};

package/lib/core-bridge.ts

@@ -1,155 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-export type CoreConfig = {
-  session?: {
-    store?: string;
-  };
-  [key: string]: unknown;
-};
-
-type CoreAgentDeps = {
-  resolveAgentDir: (cfg: CoreConfig, agentId: string) => string;
-  resolveAgentWorkspaceDir: (cfg: CoreConfig, agentId: string) => string;
-  resolveAgentIdentity: (
-    cfg: CoreConfig,
-    agentId: string,
-  ) => { name?: string | null } | null | undefined;
-  resolveThinkingDefault: (params: {
-    cfg: CoreConfig;
-    provider?: string;
-    model?: string;
-  }) => string;
-  runEmbeddedPiAgent: (params: {
-    sessionId: string;
-    sessionKey?: string;
-    messageProvider?: string;
-    sessionFile: string;
-    workspaceDir: string;
-    config?: CoreConfig;
-    prompt: string;
-    provider?: string;
-    model?: string;
-    thinkLevel?: string;
-    verboseLevel?: string;
-    timeoutMs: number;
-    runId: string;
-    lane?: string;
-    extraSystemPrompt?: string;
-    agentDir?: string;
-  }) => Promise<{
-    payloads?: Array<{ text?: string; isError?: boolean }>;
-    meta?: { aborted?: boolean };
-  }>;
-  resolveAgentTimeoutMs: (opts: { cfg: CoreConfig }) => number;
-  ensureAgentWorkspace: (params?: { dir: string }) => Promise<void>;
-  resolveStorePath: (store?: string, opts?: { agentId?: string }) => string;
-  loadSessionStore: (storePath: string) => Record<string, unknown>;
-  saveSessionStore: (storePath: string, store: Record<string, unknown>) => Promise<void>;
-  resolveSessionFilePath: (
-    sessionId: string,
-    entry: unknown,
-    opts?: { agentId?: string },
-  ) => string;
-  DEFAULT_MODEL: string;
-  DEFAULT_PROVIDER: string;
-};
-
-let coreRootCache: string | null = null;
-let coreDepsPromise: Promise<CoreAgentDeps> | null = null;
-
-function findPackageRoot(startDir: string, name: string): string | null {
-  let dir = startDir;
-  for (;;) {
-    const pkgPath = path.join(dir, "package.json");
-    try {
-      if (fs.existsSync(pkgPath)) {
-        const raw = fs.readFileSync(pkgPath, "utf8");
-        const pkg = JSON.parse(raw) as { name?: string };
-        if (pkg.name === name) {
-          return dir;
-        }
-      }
-    } catch {
-      // ignore parse errors and keep walking
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      return null;
-    }
-    dir = parent;
-  }
-}
-
-function resolveOpenClawRoot(): string {
-  if (coreRootCache) {
-    return coreRootCache;
-  }
-  const override = process.env.OPENCLAW_ROOT?.trim();
-  if (override) {
-    coreRootCache = override;
-    return override;
-  }
-
-  const candidates = new Set<string>();
-  if (process.argv[1]) {
-    candidates.add(path.dirname(process.argv[1]));
-  }
-  candidates.add(process.cwd());
-  try {
-    const urlPath = fileURLToPath(import.meta.url);
-    candidates.add(path.dirname(urlPath));
-  } catch {
-    // ignore
-  }
-
-  for (const start of candidates) {
-    for (const name of ["openclaw"]) {
-      const found = findPackageRoot(start, name);
-      if (found) {
-        coreRootCache = found;
-        return found;
-      }
-    }
-  }
-
-  throw new Error("Unable to resolve core root. Set OPENCLAW_ROOT to the package root.");
-}
-
-async function importCoreExtensionAPI(): Promise<{
-  resolveAgentDir: CoreAgentDeps["resolveAgentDir"];
-  resolveAgentWorkspaceDir: CoreAgentDeps["resolveAgentWorkspaceDir"];
-  DEFAULT_MODEL: string;
-  DEFAULT_PROVIDER: string;
-  resolveAgentIdentity: CoreAgentDeps["resolveAgentIdentity"];
-  resolveThinkingDefault: CoreAgentDeps["resolveThinkingDefault"];
-  runEmbeddedPiAgent: CoreAgentDeps["runEmbeddedPiAgent"];
-  resolveAgentTimeoutMs: CoreAgentDeps["resolveAgentTimeoutMs"];
-  ensureAgentWorkspace: CoreAgentDeps["ensureAgentWorkspace"];
-  resolveStorePath: CoreAgentDeps["resolveStorePath"];
-  loadSessionStore: CoreAgentDeps["loadSessionStore"];
-  saveSessionStore: CoreAgentDeps["saveSessionStore"];
-  resolveSessionFilePath: CoreAgentDeps["resolveSessionFilePath"];
-}> {
-  // Do not import any other module. You can't touch this or you will be fired.
-  const distPath = path.join(resolveOpenClawRoot(), "dist", "extensionAPI.js");
-  if (!fs.existsSync(distPath)) {
-    throw new Error(
-      `Missing core module at ${distPath}. Run \`pnpm build\` or install the official package.`,
-    );
-  }
-  return await import(pathToFileURL(distPath).href);
-}
-
-export async function loadCoreAgentDeps(): Promise<CoreAgentDeps> {
-  if (coreDepsPromise) {
-    return coreDepsPromise;
-  }
-
-  coreDepsPromise = (async () => {
-    return await importCoreExtensionAPI();
-  })();
-
-  return coreDepsPromise;
-}

package/lib/helpers/parse-content-disposition.ts

@@ -1,21 +0,0 @@
-/**
- * Parse the filename from a Content-Disposition header.
- * Handles both `filename="..."` and RFC 5987 `filename*=UTF-8''...` forms.
- * Returns null if not found or unparseable.
- */
-export function parseContentDispositionFilename(header?: string): string | null {
-  if (!header) return null;
-  // RFC 5987: filename*=UTF-8''encoded%20name.pdf  (takes priority)
-  const star = header.match(/filename\*\s*=\s*(?:UTF-8|utf-8)?''(.+?)(?:;|$)/i);
-  if (star?.[1]) {
-    try {
-      return decodeURIComponent(star[1].trim());
-    } catch (err) {
-      console.warn(`memorylake-openclaw: failed to decode Content-Disposition filename* value "${star[1]}": ${String(err)}`);
-    }
-  }
-  // Standard: filename="name.pdf" or filename=name.pdf
-  const plain = header.match(/filename\s*=\s*"?([^";]+)"?/i);
-  if (plain?.[1]) return plain[1].trim();
-  return null;
-}

package/lib/helpers/rewrite-query.ts

@@ -1,122 +0,0 @@
-import fsPromises from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import type { PluginContext } from "../plugin-context";
-import { loadCoreAgentDeps } from "../core-bridge";
-
-/**
- * Summarize recent session messages into a compact text block for the rewrite prompt.
- * Messages are unknown[] from the hook event — we extract role+content from each.
- */
-export function summarizeMessages(messages: unknown[], maxMessages = 10): string {
-  if (!messages || messages.length === 0) return "";
-  const recent = messages.slice(-maxMessages);
-  return recent
-    .map((m: any) => {
-      const role = m?.role ?? "user";
-      const content =
-        typeof m?.content === "string"
-          ? m.content
-          : JSON.stringify(m?.content ?? "");
-      return `[${role}]: ${content}`;
-    })
-    .join("\n");
-}
-
-/**
- * Resolve provider/model from config. Returns undefined for both if not found
- * (openclaw will use its own defaults).
- */
-export function resolveProviderModel(api: PluginContext["api"]): { provider: string | undefined; model: string | undefined } {
-  const modelPrimary = (api.config as any)?.agents?.defaults?.model?.primary as string | undefined;
-  if (modelPrimary) {
-    const slashIdx = modelPrimary.indexOf("/");
-    if (slashIdx >= 0) {
-      return { provider: modelPrimary.slice(0, slashIdx), model: modelPrimary.slice(slashIdx + 1) };
-    }
-    return { provider: undefined, model: modelPrimary };
-  }
-  return { provider: undefined, model: undefined };
-}
-
-/**
- * Rewrite the user's prompt into a search-optimized query using
- * openclaw's runEmbeddedPiAgent, considering conversation history.
- *
- * Priority: api.runtime.agent.runEmbeddedPiAgent → loadCoreAgentDeps()
- */
-export async function rewriteQueryForSearch(
-  api: PluginContext["api"],
-  originalPrompt: string,
-  messages: unknown[],
-  ctx: { workspaceDir?: string },
-): Promise<string> {
-  if (!ctx.workspaceDir) {
-    api.logger.warn("memorylake-openclaw: no workspaceDir, skipping query rewrite");
-    return originalPrompt;
-  }
-
-  const conversationHistory = summarizeMessages(messages);
-  const systemPrompt =
-    "You are a search query optimizer. Extract the key search intent and produce a concise, search-optimized query. Output ONLY the rewritten query, nothing else. Preserve important entities, names, dates, and technical terms.";
-  const userContent = conversationHistory
-    ? `Conversation history:\n${conversationHistory}\n\nUser's latest message:\n${originalPrompt}`
-    : originalPrompt;
-  const fullPrompt = `${systemPrompt}\n\n${userContent}`;
-
-  const { provider, model } = resolveProviderModel(api);
-  api.logger.info(`memorylake-openclaw: rewriting query via runEmbeddedPiAgent (provider=${provider}, model=${model})`);
-
-  let tempSessionFile: string | null = null;
-  try {
-    const tempDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), "memorylake-rewrite-"));
-    tempSessionFile = path.join(tempDir, "session.jsonl");
-
-    const nowMs = Date.now();
-    const callParams = {
-      sessionId: `memorylake-rewrite-${nowMs}`,
-      sessionKey: `temp:memorylake-rewrite`,
-      sessionFile: tempSessionFile,
-      workspaceDir: ctx.workspaceDir,
-      config: api.config,
-      prompt: fullPrompt,
-      provider,
-      model,
-      disableTools: true,
-      timeoutMs: 15_000,
-      runId: `memorylake-rewrite-${nowMs}`,
-      lane: `memorylake-rewrite`,
-      trigger: "memory",
-    };
-
-    // Priority 1: try api.runtime.agent.runEmbeddedPiAgent
-    let runEmbeddedPiAgent: ((p: typeof callParams) => Promise<any>) | undefined =
-      (api.runtime as any)?.agent?.runEmbeddedPiAgent;
-
-    if (typeof runEmbeddedPiAgent !== "function") {
-      api.logger.info("memorylake-openclaw: api.runtime.agent.runEmbeddedPiAgent not available, using loadCoreAgentDeps fallback");
-      const deps = await loadCoreAgentDeps();
-      runEmbeddedPiAgent = deps.runEmbeddedPiAgent;
-    }
-
-    const result = await runEmbeddedPiAgent(callParams);
-
-    const rewritten = result?.payloads?.[0]?.text?.trim();
-    if (rewritten && rewritten.length > 0) {
-      api.logger.info(`memorylake-openclaw: rewritten query: "${rewritten}"`);
-      return rewritten;
-    }
-    api.logger.warn("memorylake-openclaw: rewrite returned empty, using original");
-  } catch (err) {
-    api.logger.warn(`memorylake-openclaw: query rewrite failed, using original: ${String(err)}`);
-  } finally {
-    if (tempSessionFile) {
-      try {
-        await fsPromises.rm(path.dirname(tempSessionFile), { recursive: true, force: true });
-      } catch (cleanupErr) {
-        api.logger.warn(`memorylake-openclaw: temp session cleanup failed: ${String(cleanupErr)}`);
-      }
-    }
-  }
-  return originalPrompt;
-}

package/lib/helpers/upload-record.ts

@@ -1,47 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-const UPLOADED_RECORD_FILE = "uploaded.json";
-
-export type UploadedRecord = Record<string, { mtimeMs: number }>;
-
-export function getUploadedRecord(workspaceDir: string): UploadedRecord {
-  const filePath = path.join(workspaceDir, ".memorylake", UPLOADED_RECORD_FILE);
-  try {
-    if (fs.existsSync(filePath)) {
-      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-      return data && typeof data === "object" && !Array.isArray(data) ? data : {};
-    }
-  } catch {
-    // ignore read errors
-  }
-  return {};
-}
-
-export function saveUploadedRecord(workspaceDir: string, record: UploadedRecord): void {
-  const dirPath = path.join(workspaceDir, ".memorylake");
-  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(
-    path.join(dirPath, UPLOADED_RECORD_FILE),
-    JSON.stringify(record, null, 2),
-  );
-}
-
-export function needsUpload(record: UploadedRecord, filePath: string): fs.Stats | null {
-  if (!fs.existsSync(filePath)) return null;
-  const stat = fs.statSync(filePath);
-  const prev = record[filePath];
-  return (!prev || prev.mtimeMs !== stat.mtimeMs) ? stat : null;
-}
-
-export function extractInboundPaths(prompt: string): string[] {
-  // Path must contain /media/inbound/ (or \media\inbound\)
-  // Filename must end with .<ext>, ext = alphanumeric, 1-6 chars
-  const sep = '[/\\\\]';
-  const regex = new RegExp(
-    `(?:[A-Za-z]:${sep}|/)\\S*?media${sep}inbound${sep}.+?\\.[a-zA-Z0-9]{1,6}(?=[^a-zA-Z0-9]|$)`,
-    "g",
-  );
-  const matches = prompt.match(regex) || [];
-  return [...new Set(matches)];
-}

package/lib/hooks/auto-capture.ts

@@ -1,97 +0,0 @@
-import type { PluginContext } from "../plugin-context";
-import { getProvider } from "../provider";
-import { buildAddOptions } from "../utils/builders";
-import { MEMORYLAKE_REMINDER } from "./auto-recall";
-
-function stripReminder(content: string): string {
-  if (content.includes(MEMORYLAKE_REMINDER)) {
-    return content.replace(MEMORYLAKE_REMINDER, "").trim();
-  }
-  return content;
-}
-
-export function registerAutoCapture(pctx: PluginContext): void {
-  const { api, resolveConfig } = pctx;
-
-  api.on("agent_end", async (event, ctx) => {
-    if ((ctx as any)?.trigger !== "user") {
-      api.logger.info(`memorylake-openclaw: auto-capture skipped, trigger=${(ctx as any)?.trigger ?? "undefined"}`);
-      return;
-    }
-    if (!event.success || !event.messages || event.messages.length === 0) {
-      return;
-    }
-
-    // Resolve per-workspace config override
-    const effectiveCfg = resolveConfig(ctx);
-    const effectiveProvider = getProvider(effectiveCfg);
-
-    // Track session ID
-    const sessionId = (ctx as any)?.sessionId ?? undefined;
-
-    try {
-      // Extract messages, limiting to last 10
-      const recentMessages = event.messages.slice(-10);
-      const formattedMessages: Array<{
-        role: string;
-        content: string;
-      }> = [];
-
-      for (const msg of recentMessages) {
-        if (!msg || typeof msg !== "object") continue;
-        const msgObj = msg as Record<string, unknown>;
-
-        const role = msgObj.role;
-        if (role !== "user" && role !== "assistant") continue;
-
-        let textContent = "";
-        const content = msgObj.content;
-
-        if (typeof content === "string") {
-          textContent = content;
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (
-              block &&
-              typeof block === "object" &&
-              "text" in block &&
-              typeof (block as Record<string, unknown>).text === "string"
-            ) {
-              textContent +=
-                (textContent ? "\n" : "") +
-                ((block as Record<string, unknown>).text as string);
-            }
-          }
-        }
-
-        if (role === "user") {
-          textContent = stripReminder(textContent);
-        }
-
-        if (!textContent) continue;
-
-        formattedMessages.push({
-          role: role as string,
-          content: textContent,
-        });
-      }
-
-      if (formattedMessages.length === 0) return;
-
-      const addOpts = buildAddOptions(effectiveCfg, undefined, sessionId);
-      const result = await effectiveProvider.add(
-        formattedMessages,
-        addOpts,
-      );
-
-      const capturedCount = result.results?.length ?? 0;
-      if (capturedCount > 0) {
-        api.logger.info(
-          `memorylake-openclaw: auto-captured ${capturedCount} memories`,
-        );
-      }
-    } catch (err) {
-      api.logger.warn(`memorylake-openclaw: capture failed: ${String(err)}`);
-    }
-  });
-}