memorylake-openclaw 0.0.11 → 0.0.15-beta.1

package/README.md

@@ -39,7 +39,7 @@ Get an API key from [app.memorylake.ai](https://app.memorylake.ai), then add to
 
 ## Agent tools
 
-The agent gets seven tools it can call during conversations:
+The agent gets eight tools it can call during conversations:
 
 | Tool | Description |
 |------|-------------|
@@ -50,6 +50,7 @@ The agent gets seven tools it can call during conversations:
 | `memory_forget` | Delete a memory by ID |
 | `document_search` | Search project documents for relevant paragraphs, tables, and figures |
 | `advanced_web_search` | Optional tool for web search with plugin-level domain and locale constraints |
+| `open_data_search` | Search open data sources scoped to the project's configured industry categories |
 
 ## CLI
 

package/core-bridge.ts

@@ -0,0 +1,155 @@
+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/docs/openclaw.mdx

@@ -14,7 +14,7 @@ The plugin provides:
 1. **Auto-Recall** — Before the agent responds, memories and relevant document excerpts matching the current message are injected into context
 2. **Auto-Capture** — After the agent responds, the exchange is sent to MemoryLake which decides what's worth keeping
 3. **Auto-Upload** — When a user sends a file, the plugin uploads it to MemoryLake as a project document asynchronously
-4. **Agent Tools** — Seven tools for memory, document, and optional web search operations during conversations
+4. **Agent Tools** — Eight tools for memory, document, web search, and open data search operations during conversations
 
 Auto-Recall, Auto-Capture, and Auto-Upload run silently by default.
 
@@ -43,7 +43,7 @@ Add to your `openclaw.json`:
 
 ## Agent Tools
 
-The agent gets seven tools it can call during conversations:
+The agent gets eight tools it can call during conversations:
 
 | Tool | Description |
 |------|-------------|
@@ -54,6 +54,9 @@ The agent gets seven tools it can call during conversations:
 | `memory_forget` | Delete a memory by ID |
 | `document_search` | Search project documents for relevant paragraphs, tables, and figures |
 | `advanced_web_search` | Optional web search tool backed by the unified search API with plugin-level domain and locale constraints |
+| `open_data_search` | Optional search across open datasets — academic, clinical, drug, financial, economic, and more — routed to the appropriate proprietary data source based on the `dataset` field |
+
+<Note>`open_data_search` requires the project to have at least one open data industry configured in MemoryLake. The `dataset` parameter is required and validated against the project's subscribed datasets at call time. The agent is automatically informed of available datasets via context injection at the start of each session. Supported datasets: `research/academic`, `clinical/trials`, `drug/database`, `financial/markets`, `company/fundamentals`, `economic/data`, `patents/ip`.</Note>
 
 ## CLI Commands
 
@@ -83,18 +86,19 @@ openclaw memorylake stats
 | `webSearchCountry` | `string` | — | Optional ISO country code for localizing `advanced_web_search` |
 | `webSearchTimezone` | `string` | — | Optional IANA timezone for localizing `advanced_web_search` |
 
-<Note>`advanced_web_search` is registered as an optional OpenClaw tool, so it must be explicitly allowed before an agent can call it.</Note>
+<Note>`advanced_web_search` and `open_data_search` are registered as optional OpenClaw tools, so they must be explicitly allowed before an agent can call them.</Note>
 
 ## Key Features
 
 1. **Zero Configuration** — Auto-recall and auto-capture work out of the box with no prompting required
 2. **Async Processing** — Memory extraction and file uploads run asynchronously without blocking the agent
 3. **Session Tracking** — Conversations are tagged with `chat_session_id` for traceability
-4. **Rich Tool Suite** — Seven agent tools for memory, document, and optional web search operations when needed
+4. **Rich Tool Suite** — Eight agent tools for memory, document, web search, and open data search operations when needed
+5. **Open Data Awareness** — At the start of each session, the agent is automatically informed of which open data categories the project has access to, so it can use `open_data_search` with the correct category without guessing
 
 ## Conclusion
 
-The `memorylake-openclaw` plugin gives OpenClaw agents persistent memory with minimal setup. Your agents can remember user preferences, facts, and context across sessions automatically.
+The `memorylake-openclaw` plugin gives OpenClaw agents persistent memory with minimal setup. Your agents can remember user preferences, facts, and context across sessions automatically — and optionally search across a wide range of open datasets when deeper external knowledge is needed.
 
 {/*<CardGroup cols={2}>
   <Card title="MemoryLake" icon="brain" href="https://app.memorylake.ai">

package/index.ts

@@ -4,17 +4,20 @@
  * Long-term memory via MemoryLake platform.
  *
  * Features:
- * - 7 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, advanced_web_search
+ * - 8 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, advanced_web_search, open_data_search
  * - Auto-recall: injects relevant memories and document excerpts before each agent turn
  * - Auto-capture: stores key facts scoped to the current session after each agent turn
  * - CLI: openclaw memorylake search, openclaw memorylake stats
  */
 
 import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import got from "got";
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { loadCoreAgentDeps } from "./core-bridge";
 
 // ============================================================================
 // Types
@@ -65,6 +68,52 @@ interface MemoryItem {
   user_id?: string;
   created_at?: string;
   updated_at?: string;
+  has_unresolved_conflict?: boolean;
+}
+
+interface ConflictMemorySnapshot {
+  memory_id: string;
+  memory_history_id?: string;
+  memory_text: string;
+}
+
+interface ConflictFileChunk {
+  chunk: { type?: string; text: string; range?: string };
+  document_id?: string;
+  document_name?: string;
+}
+
+interface ConflictResolve {
+  id: string;
+  strategy: string;
+  keep_memory_id?: string;
+  forgotten_memory_ids?: string[];
+  resolved_by?: string;
+  created_at?: string;
+}
+
+interface ConflictItem {
+  id: string;
+  name: string;
+  description: string;
+  category: "m2m" | "m2d";
+  conflict_type: "logical" | "knowledge";
+  memory_ids: string[];
+  memory_snapshots: ConflictMemorySnapshot[];
+  file_chunks: ConflictFileChunk[];
+  resolved: boolean;
+  resolve?: ConflictResolve;
+  stale?: boolean;
+  event_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface ConflictListResponse {
+  items: ConflictItem[];
+  page: number;
+  total: number;
+  page_size: number;
 }
 
 interface AddResultItem {
@@ -168,6 +217,68 @@ interface WebSearchResponse {
   total_results: number;
 }
 
+/**
+ * Allowed values for open data search category (aligned with opendata endpoint).
+ * Maps to proprietary data sources per category.
+ */
+const OpenDataCategoryValues = [
+  "research/academic",
+  "clinical/trials",
+  "drug/database",
+  "financial/markets",
+  "company/fundamentals",
+  "economic/data",
+  "patents/ip",
+] as const;
+type OpenDataCategory = (typeof OpenDataCategoryValues)[number];
+
+const OPEN_DATA_CATEGORY_SET = new Set<string>(OpenDataCategoryValues);
+
+/** Normalize category: accept string at runtime; return undefined if not a valid enum value. */
+function normalizeOpenDataCategory(value: unknown): OpenDataCategory | undefined {
+  if (value == null) return undefined;
+  const s = typeof value === "string" ? value.toLowerCase().trim() : "";
+  return OPEN_DATA_CATEGORY_SET.has(s) ? (s as OpenDataCategory) : undefined;
+}
+
+interface OpenDataIndustry {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+interface ProjectInfo {
+  id: string;
+  name: string;
+  description?: string;
+  industries: OpenDataIndustry[];
+}
+
+interface OpenDataSearchOptions {
+  dataset?: OpenDataCategory | string;
+  max_results?: number;
+  start_date?: string;
+  end_date?: string;
+}
+
+interface OpenDataSearchResult {
+  title?: string;
+  url?: string;
+  summary?: string;
+  content?: string;
+  source?: string;
+  category?: string;
+  published_date?: string;
+  author?: string;
+  score?: number;
+  metadata?: Record<string, unknown>;
+}
+
+interface OpenDataSearchResponse {
+  results: OpenDataSearchResult[];
+  total_results: number;
+}
+
 // ============================================================================
 // Unified Provider Interface
 // ============================================================================
@@ -183,6 +294,9 @@ interface MemoryLakeProvider {
   delete(memoryId: string): Promise<void>;
   searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse>;
   searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
+  searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse>;
+  getProject(): Promise<ProjectInfo>;
+  listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]>;
 }
 
 // ============================================================================
@@ -201,11 +315,19 @@ class PlatformProvider implements MemoryLakeProvider {
   private readonly basePath: string;
   private readonly docSearchPath: string;
   private readonly webSearchPath: string;
+  private readonly openDataSearchPath: string;
+  private readonly projectPath: string;
+  private readonly conflictsPath: string;
+  private readonly projectId: string;
 
   constructor(host: string, apiKey: string, projectId: string) {
+    this.projectId = projectId;
     this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
     this.docSearchPath = `openapi/memorylake/api/v1/projects/${projectId}/documents/search`;
     this.webSearchPath = "openapi/memorylake/api/v1/search";
+    this.openDataSearchPath = "openapi/memorylake/api/v1/search/opendata";
+    this.projectPath = `openapi/memorylake/api/v1/projects/${projectId}`;
+    this.conflictsPath = `openapi/memorylake/api/v2/projects/${projectId}/memories/conflicts`;
     this.http = got.extend({
       prefixUrl: host,
       headers: {
@@ -238,6 +360,7 @@ class PlatformProvider implements MemoryLakeProvider {
     const body: Record<string, unknown> = {
       query,
       user_id: options.user_id,
+      with_conflicts: true,
     };
     if (options.top_k != null) body.top_k = options.top_k;
     if (options.threshold != null) body.threshold = options.threshold;
@@ -312,6 +435,61 @@ class PlatformProvider implements MemoryLakeProvider {
     return normalizeWebSearchResponse(resp);
   }
 
+  async searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse> {
+    const body: Record<string, unknown> = { query };
+    if (options.dataset != null) {
+      const ds = normalizeOpenDataCategory(options.dataset);
+      if (!ds) throw new Error(`Invalid open data dataset: "${options.dataset}"`);
+      body.dataset = ds;
+    }
+    if (options.max_results != null) body.max_results = options.max_results;
+    if (options.start_date) body.start_date = options.start_date;
+    if (options.end_date) body.end_date = options.end_date;
+
+    const resp = await this.http
+      .post(this.openDataSearchPath, { json: body })
+      .json<OpenDataSearchResponse>();
+    return normalizeOpenDataSearchResponse(resp);
+  }
+
+  async getProject(): Promise<ProjectInfo> {
+    const resp = await this.http
+      .get(this.projectPath)
+      .json<ApiResponse<{ id?: string; name?: string; description?: string; industries?: Array<{ id?: string; name?: string; description?: string }> }>>();
+    if (!resp.success) throw new Error(resp.message ?? "get project failed");
+    const data = resp.data;
+    const info: ProjectInfo = {
+      id: data?.id ?? "",
+      name: data?.name ?? "",
+      description: data?.description,
+      industries: Array.isArray(data?.industries)
+        ? data.industries.map((ind) => ({
+            id: ind.id ?? "",
+            name: ind.name ?? "",
+            description: ind.description,
+          }))
+        : [],
+    };
+    return info;
+  }
+
+  async listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]> {
+    if (memoryIds.length === 0) return [];
+    const searchParams: Record<string, string | string[]> = {
+      resolved: "false",
+      memory_ids: memoryIds,
+    };
+    const resp = await this.http
+      .get(this.conflictsPath, {
+        searchParams,
+        headers: { "X-User-ID": userId },
+      })
+      .json<ApiResponse<ConflictListResponse>>();
+    if (!resp.success) throw new Error(resp.message ?? "list conflicts failed");
+    const data = resp.data;
+    return Array.isArray(data?.items) ? data.items : [];
+  }
+
 }
 
 // ============================================================================
@@ -325,6 +503,7 @@ function normalizeMemoryItem(raw: any): MemoryItem {
     user_id: raw.user_id,
     created_at: raw.created_at,
     updated_at: raw.updated_at,
+    has_unresolved_conflict: raw.has_unresolved_conflict ?? false,
   };
 }
 
@@ -353,6 +532,30 @@ function normalizeWebSearchResponse(raw: any): WebSearchResponse {
   };
 }
 
+function normalizeOpenDataResult(raw: any): OpenDataSearchResult {
+  return {
+    title: typeof raw?.title === "string" ? raw.title : undefined,
+    url: typeof raw?.url === "string" ? raw.url : undefined,
+    summary: typeof raw?.summary === "string" ? raw.summary : undefined,
+    content: typeof raw?.content === "string" ? raw.content : undefined,
+    source: typeof raw?.source === "string" ? raw.source : undefined,
+    category: typeof raw?.category === "string" ? raw.category : undefined,
+    published_date: typeof raw?.published_date === "string" ? raw.published_date : undefined,
+    author: typeof raw?.author === "string" ? raw.author : undefined,
+    score: typeof raw?.score === "number" ? raw.score : undefined,
+    metadata: raw?.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)
+      ? raw.metadata as Record<string, unknown>
+      : undefined,
+  };
+}
+
+function normalizeOpenDataSearchResponse(raw: any): OpenDataSearchResponse {
+  return {
+    results: Array.isArray(raw?.results) ? raw.results.map(normalizeOpenDataResult) : [],
+    total_results: typeof raw?.total_results === "number" ? raw.total_results : 0,
+  };
+}
+
 // ============================================================================
 // Document Context Builder
 // ============================================================================
@@ -414,6 +617,37 @@ function buildWebSearchContext(results: WebSearchResult[]): string {
     .join("\n\n");
 }
 
+function buildConflictContext(conflicts: ConflictItem[], maxChunkLength = 200): string {
+  return conflicts
+    .map((c) => {
+      const parts: string[] = [
+        `- [${c.conflict_type}] ${c.description}`,
+      ];
+      for (const snap of c.memory_snapshots ?? []) {
+        parts.push(`  Memory(${snap.memory_id}): ${snap.memory_text.slice(0, maxChunkLength)}`);
+      }
+      for (const fc of c.file_chunks ?? []) {
+        const docLabel = fc.document_name ?? fc.document_id ?? "unknown";
+        parts.push(`  Document(${docLabel}): ${fc.chunk.text.slice(0, maxChunkLength)}`);
+      }
+      return parts.join("\n");
+    })
+    .join("\n");
+}
+
+function buildOpenDataContext(results: OpenDataSearchResult[]): string {
+  const filtered = results.map((r) => {
+    const item: Record<string, unknown> = {};
+    if (r.title != null) item.title = r.title;
+    if (r.url != null) item.url = r.url;
+    if (r.content != null) item.content = r.content;
+    if (r.published_date != null) item.published_date = r.published_date;
+    if (r.category != null) item.category = r.category;
+    return item;
+  });
+  return JSON.stringify(filtered, null, 2);
+}
+
 // ============================================================================
 // Config Parser
 // ============================================================================
@@ -574,16 +808,16 @@ const memoryPlugin = {
         }
 
         return { ...cfg, ...overrides } as MemoryLakeConfig;
-      } catch {
+      } catch (err) {
         api.logger.warn(
-          `memorylake-openclaw: failed to parse workspace config JSON; falling back to global config (path: ${localPath})`,
+          `memorylake-openclaw: failed to parse workspace config JSON; falling back to global config (path: ${localPath}): ${String(err)}`,
         );
         return cfg;
       }
     }
 
-    // Track current session ID for tool-level session scoping
-    let currentSessionId: string | undefined;
+    // Cache project industries per session — fetched once, reused on subsequent prompts
+    const sessionIndustriesCache = new Map<string, OpenDataIndustry[]>();
 
     api.logger.info(
       `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
@@ -742,7 +976,7 @@ const memoryPlugin = {
           try {
             const result = await effectiveProvider.add(
               [{ role: "user", content: text }],
-              buildAddOptions(effectiveCfg, userId, currentSessionId),
+              buildAddOptions(effectiveCfg, userId, (ctx as any)?.sessionId),
             );
 
             const count = result.results?.length ?? 0;
@@ -1128,6 +1362,152 @@ const memoryPlugin = {
       { optional: true },
     );
 
+    api.registerTool(
+      (ctx) => ({
+        name: "open_data_search",
+        label: "Open Data Search",
+        description:
+          "Search across open datasets routed to the appropriate proprietary data source based on the dataset:\n- research/academic: arXiv, PubMed, bioRxiv, medRxiv\n- clinical/trials: Clinical trial registries\n- drug/database: ChEMBL, DrugBank, PubChem, etc.\n- financial/markets: Stocks, crypto, forex, funds, commodities\n- company/fundamentals: SEC filings, earnings, balance sheets, etc.\n- economic/data: FRED, BLS, World Bank, etc.\n- patents/ip: USPTO patents",
+        parameters: Type.Object({
+          query: Type.String({
+            description: "The search query to send to the open data endpoint.",
+          }),
+          dataset: Type.Union(
+            [
+              Type.Literal("research/academic"),
+              Type.Literal("clinical/trials"),
+              Type.Literal("drug/database"),
+              Type.Literal("financial/markets"),
+              Type.Literal("company/fundamentals"),
+              Type.Literal("economic/data"),
+              Type.Literal("patents/ip"),
+            ],
+            {
+              description:
+                "Dataset category to search. Must be one of the project's enabled categories.",
+            },
+          ),
+          maxResults: Type.Optional(
+            Type.Number({
+              description: `Maximum number of results to return (default: ${cfg.topK}). The server enforces a hard cap.`,
+              minimum: 1,
+            }),
+          ),
+          startDate: Type.Optional(
+            Type.String({
+              description: "Only include results published on or after this date (YYYY-MM-DD).",
+            }),
+          ),
+          endDate: Type.Optional(
+            Type.String({
+              description: "Only include results published on or before this date (YYYY-MM-DD).",
+            }),
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
+          const {
+            query,
+            dataset: rawDataset,
+            maxResults,
+            startDate,
+            endDate,
+          } = params as {
+            query: string;
+            dataset: string;
+            maxResults?: number;
+            startDate?: string;
+            endDate?: string;
+          };
+
+          // Normalize once; use throughout to avoid casing bugs
+          const dataset = normalizeOpenDataCategory(rawDataset);
+
+          if (!dataset) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Unsupported dataset: "${rawDataset}". Supported values are: ${OpenDataCategoryValues.join(", ")}`,
+                },
+              ],
+              details: { error: "unsupported_dataset", dataset: rawDataset },
+            };
+          }
+
+          try {
+            // Validate dataset against project's allowed industries
+            const projectInfo = await effectiveProvider.getProject();
+            if (projectInfo.industries.length > 0) {
+              const allowedIds = projectInfo.industries.map((ind) => ind.id);
+              if (!allowedIds.includes(dataset)) {
+                const allowed = projectInfo.industries
+                  .map((ind) => `${ind.id} (${ind.name})`)
+                  .join(", ");
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Dataset "${dataset}" is not enabled for this project. Allowed datasets: ${allowed}`,
+                    },
+                  ],
+                  details: {
+                    error: "dataset_not_allowed",
+                    dataset,
+                    allowed_datasets: allowedIds,
+                  },
+                };
+              }
+            }
+
+            const response = await effectiveProvider.searchOpenData(query, {
+              dataset,
+              max_results: maxResults ?? effectiveCfg.topK,
+              start_date: startDate,
+              end_date: endDate,
+            });
+
+            if (!response.results || response.results.length === 0) {
+              return {
+                content: [
+                  { type: "text", text: "No relevant open data results found." },
+                ],
+                details: { count: 0, total_results: response.total_results },
+              };
+            }
+
+            const context = buildOpenDataContext(response.results);
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${response.results.length} open data results:\n\n${context}`,
+                },
+              ],
+              details: {
+                count: response.results.length,
+                total_results: response.total_results,
+                results: response.results,
+              },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Open data search failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { optional: true },
+    );
+
     // ========================================================================
     // CLI Commands
     // ========================================================================
@@ -1247,6 +1627,10 @@ const memoryPlugin = {
       let uploadFn: ((opts: { host: string; apiKey: string; projectId: string; filePath: string; fileName: string }) => Promise<unknown>) | undefined;
 
       api.on("before_prompt_build", (event, ctx) => {
+        if ((ctx as any)?.trigger !== "user") {
+          api.logger.info(`memorylake-openclaw: auto-upload skipped, trigger=${(ctx as any)?.trigger ?? "undefined"}`);
+          return;
+        }
         const workspaceDir = (ctx as any)?.workspaceDir;
         if (!workspaceDir || !event.prompt) return;
 
@@ -1303,36 +1687,214 @@ const memoryPlugin = {
       });
     }
 
-    // Auto-recall: inject relevant memories and documents before agent starts
+    // ------------------------------------------------------------------
+    // LLM Query Rewrite Helpers
+    // ------------------------------------------------------------------
+
+    /**
+     * 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.
+     */
+    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");
+    }
+
+    // (loadCoreAgentDeps is defined at module scope above)
+
+    /**
+     * Resolve provider/model from config. Returns undefined for both if not found
+     * (openclaw will use its own defaults).
+     */
+    function resolveProviderModel(): { 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()
+     */
+    async function rewriteQueryForSearch(
+      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.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;
+    }
+
+    // ------------------------------------------------------------------
+    // Auto-recall: inject relevant memories and documents before prompt build
+    // ------------------------------------------------------------------
     if (cfg.autoRecall) {
-      api.on("before_agent_start", async (event, ctx) => {
-        if (!event.prompt || event.prompt.length < 5) return;
+      api.on("before_prompt_build", async (event, ctx) => {
+        if ((ctx as any)?.trigger !== "user") {
+          api.logger.info(`memorylake-openclaw: auto-recall skipped, trigger=${(ctx as any)?.trigger ?? "undefined"}`);
+          return;
+        }
+        if (!event.prompt) return;
 
-        // Resolve per-workspace config override
         const effectiveCfg = resolveConfig(ctx);
         const effectiveProvider = getProvider(effectiveCfg);
 
-        // Track session ID
-        const sessionId = (ctx as any)?.sessionKey ?? undefined;
-        if (sessionId) currentSessionId = sessionId;
+        const sessionId = (ctx as any)?.sessionId ?? undefined;
+
+        // LLM-rewrite FIRST — short prompts like "它呢？" can become meaningful
+        // search queries when the LLM has conversation history context.
+        const searchQuery = await rewriteQueryForSearch(event.prompt, event.messages, ctx);
+
+        // Only skip if the rewritten result is still too short
+        if (searchQuery.length < 5) {
+          api.logger.info(
+            `memorylake-openclaw: skipping auto-recall, rewritten query too short (${searchQuery.length} chars)`,
+          );
+          return;
+        }
+
+        // Fetch industries once per session, then cache
+        let industries: OpenDataIndustry[] | undefined;
+        if (sessionId && sessionIndustriesCache.has(sessionId)) {
+          industries = sessionIndustriesCache.get(sessionId);
+        } else {
+          try {
+            const projectInfo = await effectiveProvider.getProject();
+            industries = projectInfo.industries;
+            if (sessionId) {
+              sessionIndustriesCache.set(sessionId, industries);
+            }
+          } catch (err) {
+            api.logger.warn(`memorylake-openclaw: project info fetch failed: ${String(err)}`);
+          }
+        }
 
         const [memoryResult, docResult] = await Promise.allSettled([
-          effectiveProvider.search(event.prompt, buildSearchOptions(effectiveCfg)),
-          effectiveProvider.searchDocuments(event.prompt, effectiveCfg.topK),
+          effectiveProvider.search(searchQuery, buildSearchOptions(effectiveCfg)),
+          effectiveProvider.searchDocuments(searchQuery, effectiveCfg.topK),
         ]);
 
         const contextParts: string[] = [];
 
         if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-          const memoryContext = memoryResult.value
+          const memories = memoryResult.value;
+          const memoryContext = memories
             .map((r) => `- ${r.content}`)
             .join("\n");
           contextParts.push(
             `<relevant-memories>\nThe following memories may be relevant to this conversation:\n${memoryContext}\n</relevant-memories>`,
           );
           api.logger.info(
-            `memorylake-openclaw: injecting ${memoryResult.value.length} memories into context`,
+            `memorylake-openclaw: injecting ${memories.length} memories into context`,
           );
+
+          // Fetch conflict details for memories flagged with unresolved conflicts
+          const conflictedIds = memories
+            .filter((m) => m.has_unresolved_conflict)
+            .map((m) => m.id);
+          if (conflictedIds.length > 0) {
+            try {
+              const conflicts = await effectiveProvider.listConflicts(conflictedIds, effectiveCfg.userId);
+              if (conflicts.length > 0) {
+                const conflictContext = buildConflictContext(conflicts);
+                contextParts.push(
+                  `<memory-conflicts>\nThe following conflicts exist among the recalled memories. ` +
+                  `Consider these contradictions when using the above memories.\n` +
+                  `If you have not already informed the user about these conflicts in this conversation, briefly mention that some recalled memories contain contradictions and note which points are uncertain. Do not repeat this notice if you have already done so.\n` +
+                  `${conflictContext}\n</memory-conflicts>`,
+                );
+                api.logger.info(
+                  `memorylake-openclaw: injecting ${conflicts.length} memory conflicts into context`,
+                );
+              }
+            } catch (err) {
+              api.logger.warn(`memorylake-openclaw: conflict fetch failed: ${String(err)}`);
+            }
+          }
         } else if (memoryResult.status === "rejected") {
           api.logger.warn(`memorylake-openclaw: memory recall failed: ${String(memoryResult.reason)}`);
         }
@@ -1349,15 +1911,36 @@ const memoryPlugin = {
           api.logger.warn(`memorylake-openclaw: document search failed: ${String(docResult.reason)}`);
         }
 
-        if (contextParts.length === 0) return;
+        const result: { prependContext?: string; appendSystemContext?: string } = {};
+
+        if (contextParts.length > 0) {
+          result.prependContext = contextParts.join("\n\n");
+        }
+
+        if (industries && industries.length > 0) {
+          const categoryList = industries
+            .map((ind) => `- ${ind.id}: ${ind.name}${ind.description ? ` — ${ind.description}` : ""}`)
+            .join("\n");
+          result.appendSystemContext =
+            `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`;
+          api.logger.info(
+            `memorylake-openclaw: injecting ${industries.length} open data categories into system context`,
+          );
+        }
+
+        if (!result.prependContext && !result.appendSystemContext) return;
 
-        return { prependContext: contextParts.join("\n\n") };
+        return result;
       });
     }
 
     // Auto-capture: store conversation context after agent ends
     if (cfg.autoCapture) {
       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;
         }
@@ -1367,8 +1950,7 @@ const memoryPlugin = {
         const effectiveProvider = getProvider(effectiveCfg);
 
         // Track session ID
-        const sessionId = (ctx as any)?.sessionKey ?? undefined;
-        if (sessionId) currentSessionId = sessionId;
+        const sessionId = (ctx as any)?.sessionId ?? undefined;
 
         try {
           // Extract messages, limiting to last 10
@@ -1410,9 +1992,13 @@ const memoryPlugin = {
             if (textContent.includes("<relevant-memories>")) {
               textContent = textContent.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>\s*/g, "").trim();
             }
+            if (textContent.includes("<memory-conflicts>")) {
+              textContent = textContent.replace(/<memory-conflicts>[\s\S]*?<\/memory-conflicts>\s*/g, "").trim();
+            }
             if (textContent.includes("<relevant-documents>")) {
               textContent = textContent.replace(/<relevant-documents>[\s\S]*?<\/relevant-documents>\s*/g, "").trim();
             }
+
             if (!textContent) continue;
 
             formattedMessages.push({
@@ -1423,7 +2009,7 @@ const memoryPlugin = {
 
           if (formattedMessages.length === 0) return;
 
-          const addOpts = buildAddOptions(effectiveCfg, undefined, currentSessionId);
+          const addOpts = buildAddOptions(effectiveCfg, undefined, sessionId);
           const result = await effectiveProvider.add(
             formattedMessages,
             addOpts,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.11",
+  "version": "0.0.15-beta.1",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",

package/scripts/install.ps1

@@ -35,9 +35,9 @@ $QCLAW_CONFIG = "$env:USERPROFILE\.qclaw\openclaw.json"
 function Write-Message {
     param([string]$Message, [string]$Level = "info")
     $msg = switch ($Level) {
-        "success" { "$ColorSuccess✓$ColorReset $Message" }
+        "success" { "$ColorSuccess[OK]$ColorReset $Message" }
         "warn"    { "$ColorWarn!$ColorReset $Message" }
-        "error"   { "$ColorError✗$ColorReset $Message" }
+        "error"   { "$ColorError[X]$ColorReset $Message" }
         default   { "$ColorMuted·$ColorReset $Message" }
     }
     Write-Host $msg