memorylake-openclaw 1.0.2-beta.6 → 1.1.0

package/index.ts

@@ -4,791 +4,24 @@
  * Long-term memory via MemoryLake platform.
  *
  * Features:
- * - 9 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, document_download, advanced_web_search, open_data_search
- * - Auto-recall: injects relevant memories and document excerpts before each agent turn
+ * - 7 tools: retrieve_context, memory_store, memory_list, memory_forget, document_download, advanced_web_search, open_data_search
+ * - Auto-recall: injects retrieve_context instructions (+ open-data categories) into system prompt and per-turn context
  * - Auto-capture: stores key facts scoped to the current session after each agent turn
+ * - Auto-upload: uploads inbound files to MemoryLake as project documents
  * - CLI: openclaw memorylake search, openclaw memorylake stats, openclaw memorylake upload
  */
 
-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 { pipeline } from "node:stream/promises";
-import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { loadCoreAgentDeps } from "./core-bridge";
-
-// ============================================================================
-// Types
-// ============================================================================
-const DEFAULT_USER_ID = "default";
-
-type MemoryLakeConfig = {
-  host: string;
-  apiKey: string;
-  projectId: string;
-  userId: string;
-  autoCapture: boolean;
-  autoRecall: boolean;
-  autoUpload: boolean;
-  searchThreshold: number;
-  topK: number;
-  rerank: boolean;
-  webSearchIncludeDomains?: string[];
-  webSearchExcludeDomains?: string[];
-  webSearchCountry?: string;
-  webSearchTimezone?: string;
-};
-
-// V2 API option types
-interface AddOptions {
-  user_id: string;
-  chat_session_id?: string;
-  metadata?: Record<string, unknown>;
-  infer?: boolean;
-}
-
-interface SearchOptions {
-  user_id: string;
-  top_k?: number;
-  threshold?: number;
-  rerank?: boolean;
-}
-
-interface ListOptions {
-  user_id?: string;
-  page?: number;
-  size?: number;
-}
-
-interface MemoryItem {
-  id: string;
-  content: string;
-  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 {
-  event_id: string;
-  status: string;
-  message: string;
-}
-
-interface AddResult {
-  results: AddResultItem[];
-}
-
-interface DocumentSearchResult {
-  type: "table" | "paragraph" | "figure";
-  document_id?: string;
-  document_name?: string;
-  source_document?: { file_name?: string };
-  highlight?: {
-    chunks?: Array<{ text?: string; range?: string }>;
-    inner_tables?: Array<{
-      id?: string;
-      columns?: Array<{ name?: string; data_type?: string }>;
-      num_rows?: number;
-    }>;
-    figure?: {
-      text?: string;
-      caption?: string;
-      summary_text?: string;
-    };
-  };
-  title?: string;
-  footnote?: string;
-  sheet_name?: string;
-  figure_id?: number;
-}
-
-interface DocumentSearchResponse {
-  count: number;
-  results: DocumentSearchResult[];
-}
-
-/**
- * Allowed values for web search domain (aligned with zootopia unified_search Domain).
- * Declared as enum in schema; at runtime accept string and fall back to "auto" if invalid.
- */
-const WebSearchDomainValues = [
-  "web",
-  "academic",
-  "news",
-  "people",
-  "company",
-  "financial",
-  "markets",
-  "code",
-  "legal",
-  "government",
-  "poi",
-  "auto",
-] as const;
-type WebSearchDomain = (typeof WebSearchDomainValues)[number];
-
-const WEB_SEARCH_DOMAIN_SET = new Set<string>(WebSearchDomainValues);
-
-/** Normalize domain: accept string at runtime; if not a valid enum value, return "auto". */
-function normalizeWebSearchDomain(value: unknown): WebSearchDomain {
-  if (value == null) return "auto";
-  const s = typeof value === "string" ? value.toLowerCase().trim() : "";
-  return (WEB_SEARCH_DOMAIN_SET.has(s) ? s : "auto") as WebSearchDomain;
-}
-
-interface WebSearchUserLocation {
-  country?: string;
-  timezone?: string;
-}
-
-interface WebSearchOptions {
-  /** Declared as enum in schema; at runtime accept string, normalized with fallback to "auto". */
-  domain?: WebSearchDomain | string;
-  max_results?: number;
-  start_date?: string;
-  end_date?: string;
-  include_domains?: string[];
-  exclude_domains?: string[];
-  user_location?: WebSearchUserLocation;
-}
-
-interface WebSearchResult {
-  url?: string;
-  title?: string;
-  summary?: string;
-  content?: string;
-  source?: string;
-  published_date?: string;
-  author?: string;
-  score?: number;
-  highlights?: string[];
-}
-
-interface WebSearchResponse {
-  results: WebSearchResult[];
-  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
-// ============================================================================
-
-interface MemoryLakeProvider {
-  add(
-    messages: Array<{ role: string; content: string }>,
-    options: AddOptions,
-  ): Promise<AddResult>;
-  search(query: string, options: SearchOptions): Promise<MemoryItem[]>;
-  get(memoryId: string): Promise<MemoryItem>;
-  getAll(options: ListOptions): Promise<MemoryItem[]>;
-  delete(memoryId: string): Promise<void>;
-  searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse>;
-  getDocumentDownloadUrl(documentId: string): Promise<string>;
-  searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
-  searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse>;
-  getProject(): Promise<ProjectInfo>;
-  listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]>;
-}
-
-// ============================================================================
-// Platform Provider (MemoryLake Cloud)
-// ============================================================================
-
-interface ApiResponse<T = unknown> {
-  success: boolean;
-  message?: string;
-  data?: T;
-  error_code?: string;
-}
-
-class PlatformProvider implements MemoryLakeProvider {
-  private readonly http: ReturnType<typeof got.extend>;
-  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: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-      responseType: "json",
-    });
-  }
-
-  async add(
-    messages: Array<{ role: string; content: string }>,
-    options: AddOptions,
-  ): Promise<AddResult> {
-    const body: Record<string, unknown> = {
-      messages,
-      user_id: options.user_id,
-      infer: options.infer ?? true,
-    };
-    if (options.chat_session_id) body.chat_session_id = options.chat_session_id;
-    if (options.metadata) body.metadata = options.metadata;
-
-    const resp = await this.http
-      .post(this.basePath, { json: body })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "add failed");
-    return normalizeAddResult(resp.data);
-  }
-
-  async search(query: string, options: SearchOptions): Promise<MemoryItem[]> {
-    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;
-    if (options.rerank != null) body.rerank = options.rerank;
-
-    
-    const resp = await this.http
-      .post(`${this.basePath}/search`, { json: body })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "search failed");
-
-    return normalizeSearchResults(resp.data);
-  }
-
-  async get(memoryId: string): Promise<MemoryItem> {
-    const resp = await this.http
-      .get(`${this.basePath}/${memoryId}`)
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "get failed");
-    return normalizeMemoryItem(resp.data);
-  }
-
-  async getAll(options: ListOptions): Promise<MemoryItem[]> {
-    const searchParams: Record<string, string | number> = {};
-    if (options.user_id) searchParams.user_id = options.user_id;
-    if (options.page != null) searchParams.page = options.page;
-    if (options.size != null) searchParams.size = options.size;
-
-    const resp = await this.http
-      .get(this.basePath, { searchParams })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "getAll failed");
-    const data = resp.data as any;
-    if (data?.items && Array.isArray(data.items))
-      return data.items.map(normalizeMemoryItem);
-    return [];
-  }
-
-  async delete(memoryId: string): Promise<void> {
-    const resp = await this.http
-      .delete(`${this.basePath}/${memoryId}`)
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "delete failed");
-  }
-
-  async searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse> {
-    const resp = await this.http
-      .post(this.docSearchPath, { json: { query, top_N: topN } })
-      .json<ApiResponse>();
-    if (!resp.success) throw new Error(resp.message ?? "document search failed");
-    const data = resp.data as any;
-    return {
-      count: data?.count ?? 0,
-      results: Array.isArray(data?.results) ? data.results : [],
-    };
-  }
-
-  async getDocumentDownloadUrl(documentId: string): Promise<string> {
-    const downloadPath = `openapi/memorylake/api/v1/projects/${this.projectId}/documents/${documentId}/download`;
-    const resp = await this.http.get(downloadPath, {
-      followRedirect: false,
-      responseType: "text" as any,
-      throwHttpErrors: false,
-    });
-    if (resp.statusCode === 303 || resp.statusCode === 302) {
-      const location = resp.headers.location;
-      if (!location) throw new Error("Download redirect missing Location header");
-      return location;
-    }
-    if (resp.statusCode === 404) {
-      throw new Error(`Document not found: ${documentId}`);
-    }
-    throw new Error(`Unexpected download response status: ${resp.statusCode}`);
-  }
-
-  async searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse> {
-    const domain = options.domain != null ? normalizeWebSearchDomain(options.domain) : "web";
-    const body: Record<string, unknown> = {
-      query,
-      domain,
-    };
-    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;
-    if (options.include_domains?.length) body.include_domains = options.include_domains;
-    if (options.exclude_domains?.length) body.exclude_domains = options.exclude_domains;
-    if (options.user_location) body.user_location = options.user_location;
-
-    const resp = await this.http
-      .post(this.webSearchPath, { json: body })
-      .json<WebSearchResponse>();
-    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> = {
-      resolved: "false",
-      memory_ids: memoryIds.join(","),
-    };
-    const resp = await this.http
-      .get(this.conflictsPath, {
-        searchParams
-      })
-      .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 : [];
-  }
-
-}
-
-// ============================================================================
-// Result Normalizers
-// ============================================================================
-
-function normalizeMemoryItem(raw: any): MemoryItem {
-  return {
-    id: raw.id ?? "",
-    content: raw.content ?? "",
-    user_id: raw.user_id,
-    created_at: raw.created_at,
-    updated_at: raw.updated_at,
-    has_unresolved_conflict: raw.has_unresolved_conflict ?? false,
-  };
-}
-
-function normalizeSearchResults(raw: any): MemoryItem[] {
-  if (raw?.results && Array.isArray(raw.results))
-    return raw.results.map(normalizeMemoryItem);
-  if (Array.isArray(raw)) return raw.map(normalizeMemoryItem);
-  return [];
-}
-
-function normalizeAddResult(raw: any): AddResult {
-  const items = raw?.results ?? (Array.isArray(raw) ? raw : []);
-  return {
-    results: items.map((r: any) => ({
-      event_id: r.event_id ?? "",
-      status: r.status ?? "",
-      message: r.message ?? "",
-    })),
-  };
-}
-
-function normalizeWebSearchResponse(raw: any): WebSearchResponse {
-  return {
-    results: Array.isArray(raw?.results) ? raw.results : [],
-    total_results: typeof raw?.total_results === "number" ? raw.total_results : 0,
-  };
-}
-
-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
-// ============================================================================
-
-function buildDocumentContext(
-  results: DocumentSearchResult[],
-  maxChunkLength = 10000,
-): string {
-  const parts: string[] = [];
-
-  for (const result of results) {
-    const source = result.document_name ?? result.source_document?.file_name ?? "unknown";
-    const docId = result.document_id ?? "unknown";
-    const highlight = result.highlight;
-
-    if (result.type === "table") {
-      const title = result.title || "Untitled Table";
-      parts.push(`### Table: ${title} (from ${source}, doc_id: ${docId})`);
-      if (result.footnote) parts.push(`Note: ${result.footnote}`);
-
-      for (const innerTable of highlight?.inner_tables ?? []) {
-        const colDesc = (innerTable.columns ?? [])
-          .map((c) => `${c.name}(${c.data_type})`)
-          .join(", ");
-        if (colDesc) parts.push(`Columns: ${colDesc}`);
-        if (innerTable.num_rows != null) parts.push(`Rows: ${innerTable.num_rows}`);
-      }
-      for (const chunk of highlight?.chunks ?? []) {
-        if (chunk.text) parts.push(chunk.text.slice(0, maxChunkLength));
-      }
-    } else if (result.type === "paragraph") {
-      parts.push(`### Paragraph (from ${source}, doc_id: ${docId}):`);
-      for (const chunk of highlight?.chunks ?? []) {
-        if (chunk.text) parts.push(chunk.text.slice(0, maxChunkLength));
-      }
-    } else if (result.type === "figure") {
-      const figure = highlight?.figure;
-      if (figure) {
-        parts.push(`### Figure (from ${source}, doc_id: ${docId}):`);
-        if (figure.caption) parts.push(`Caption: ${figure.caption}`);
-        const text = figure.text || figure.summary_text || "";
-        if (text) parts.push(text);
-      }
-    }
-  }
-
-  return parts.join("\n\n");
-}
-
-function buildWebSearchContext(results: WebSearchResult[]): string {
-  return results
-    .map((result, index) => {
-      const parts = [`${index + 1}. ${result.title ?? result.url ?? "Untitled result"}`];
-      if (result.url) parts.push(`URL: ${result.url}`);
-      if (result.summary) parts.push(`Summary: ${result.summary}`);
-      if (result.source) parts.push(`Source: ${result.source}`);
-      if (result.published_date) parts.push(`Published: ${result.published_date}`);
-      return parts.join("\n");
-    })
-    .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
-// ============================================================================
-
-// ============================================================================
-// Config Schema
-// ============================================================================
-
-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;
-}
-
-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",
-      ),
-    };
-  },
-};
-
-// ============================================================================
-// Plugin Definition
-// ============================================================================
-
-/** Shared type for the upload / uploadAuto function signature */
-type UploadFn = (opts: {
-  host: string;
-  apiKey: string;
-  projectId: string;
-  filePath: string;
-  fileName: string;
-}) => Promise<unknown>;
+import { memoryLakeConfigSchema } from "./lib/config";
+import { createPluginContext } from "./lib/plugin-context";
+import { registerMemoryPromptSection } from "./lib/prompt/register-prompt";
+import { registerMemoryTools } from "./lib/tools/memory-tools";
+import { registerDocumentTools } from "./lib/tools/document-tools";
+import { registerSearchTools } from "./lib/tools/search-tools";
+import { registerCli } from "./lib/cli/register-cli";
+import { registerAutoUpload } from "./lib/hooks/auto-upload";
+import { registerAutoRecall } from "./lib/hooks/auto-recall";
+import { registerAutoCapture } from "./lib/hooks/auto-capture";
 
 const memoryPlugin = {
   id: "memorylake-openclaw",
@@ -799,1434 +32,21 @@ const memoryPlugin = {
 
   register(api: OpenClawPluginApi) {
     const cfg = memoryLakeConfigSchema.parse(api.pluginConfig);
-    const provider: MemoryLakeProvider = new PlatformProvider(cfg.host, cfg.apiKey, cfg.projectId);
-
-    // Provider cache: avoids re-creating providers for the same host+apiKey+projectId
-    const providerCache = new Map<string, MemoryLakeProvider>();
-    const globalProviderKey = `${cfg.host}|${cfg.apiKey}|${cfg.projectId}`;
-    providerCache.set(globalProviderKey, provider);
-
-    function getProvider(effectiveCfg: MemoryLakeConfig): MemoryLakeProvider {
-      const key = `${effectiveCfg.host}|${effectiveCfg.apiKey}|${effectiveCfg.projectId}`;
-      let p = providerCache.get(key);
-      if (!p) {
-        p = new PlatformProvider(effectiveCfg.host, effectiveCfg.apiKey, effectiveCfg.projectId);
-        providerCache.set(key, p);
-      }
-      return p;
-    }
-
-    function resolveConfig(ctx: any): MemoryLakeConfig {
-      const workspaceDir = ctx?.workspaceDir;
-      if (!workspaceDir) return cfg;
-
-      const localPath = path.join(workspaceDir, ".memorylake", "config.json");
-      if (!fs.existsSync(localPath)) return cfg;
-
-      try {
-        const raw = JSON.parse(fs.readFileSync(localPath, "utf-8"));
-        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-          api.logger.warn(
-            `memorylake-openclaw: workspace config exists but is not a JSON object; falling back to global config (path: ${localPath})`,
-          );
-          return cfg;
-        }
-
-        const allowed = new Set(ALLOWED_KEYS);
-        const overrides: Record<string, unknown> = {};
-        for (const [key, value] of Object.entries(raw)) {
-          if (allowed.has(key)) overrides[key] = value;
-        }
-
-        return { ...cfg, ...overrides } as MemoryLakeConfig;
-      } catch (err) {
-        api.logger.warn(
-          `memorylake-openclaw: failed to parse workspace config JSON; falling back to global config (path: ${localPath}): ${String(err)}`,
-        );
-        return cfg;
-      }
-    }
-
-    // Cache project industries per session — fetched once, reused on subsequent prompts
-    const sessionIndustriesCache = new Map<string, OpenDataIndustry[]>();
+    const pctx = createPluginContext(api, cfg);
 
-    // ========================================================================
-    // System Prompt: Memory Section (injected into every system prompt)
-    // ========================================================================
-    api.registerMemoryPromptSection((params) => {
-      const lines: string[] = [
-        "## Memory (MANDATORY — MemoryLake)",
-        "",
-        "You have access to MemoryLake, a long-term memory system that stores the user's preferences, history, personal context, and uploaded documents across sessions.",
-        "",
-      ];
-
-      if (params.availableTools.has("memory_search")) {
-        lines.push(
-          "### memory_search — MUST be called BEFORE every response",
-          "",
-          "**RULE: Your FIRST action for EVERY user message MUST be calling `memory_search`.** No exceptions.",
-          "",
-          "This tool searches BOTH memories AND documents in one call. It returns personal context (preferences, history, decisions) and relevant document excerpts (uploaded files, tables, figures).",
-          "",
-          "This applies to ALL types of questions, not just questions about memory or recall:",
-          "- Greetings -> search for who the user is",
-          "- Recommendations (books, activities, food) -> search for preferences and interests",
-          "- Advice (what to wear, what to eat) -> search for habits, location, preferences",
-          "- Tasks (write an email, self-introduction) -> search for user name, role, background",
-          "- Document questions -> search for relevant uploaded document content",
-          "- General chat -> search for recent context and ongoing topics",
-          "",
-          "Derive a broad query from the user's message. For example:",
-          "- User asks for a book recommendation -> search: reading preferences favorite books",
-          "- User asks about weekend plans -> search: hobbies interests weekend activities",
-          "- User says hello -> search: user name background recent context",
-          "",
-          "**If you respond without calling memory_search first, your response is WRONG.**",
-          "",
-        );
-      }
-
-      if (params.availableTools.has("memory_list")) {
-        lines.push(
-          "### memory_list",
-          "- When the user asks what you remember or wants to see all stored memories, call `memory_list`.",
-          "",
-        );
-      }
-
-      if (params.availableTools.has("memory_forget")) {
-        lines.push(
-          "### memory_forget",
-          "- When the user explicitly asks to delete or forget a specific memory, call `memory_forget` with the memory ID.",
-          "",
-        );
-      }
-
-      return lines;
-    });
+    registerMemoryPromptSection(pctx, cfg);
 
     api.logger.info(
       `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
     );
 
-    // Helper: build add options
-    function buildAddOptions(effectiveCfg: MemoryLakeConfig, userIdOverride?: string, sessionId?: string): AddOptions {
-      const opts: AddOptions = {
-        user_id: userIdOverride || effectiveCfg.userId,
-        infer: true,
-        metadata: { source: "OPENCLAW" },
-      };
-      if (sessionId) opts.chat_session_id = sessionId;
-      return opts;
-    }
-
-    // Helper: build search options
-    function buildSearchOptions(
-      effectiveCfg: MemoryLakeConfig,
-      userIdOverride?: string,
-      limit?: number,
-    ): SearchOptions {
-      return {
-        user_id: userIdOverride || effectiveCfg.userId,
-        top_k: limit ?? effectiveCfg.topK,
-        threshold: effectiveCfg.searchThreshold,
-        rerank: effectiveCfg.rerank,
-      };
-    }
-
-    // ========================================================================
-    // Tools
-    // ========================================================================
-
-    api.registerTool(
-      (ctx) => ({
-        name: "memory_search",
-        label: "Memory Search",
-        description:
-          "MANDATORY: Search through long-term memories AND uploaded documents stored in MemoryLake. You MUST call this tool at the start of every conversation to recall the user's context, preferences, past decisions, previously discussed topics, and relevant document content. Always search before answering.",
-        parameters: Type.Object({
-          query: Type.String({ description: "Search query" }),
-          limit: Type.Optional(
-            Type.Number({
-              description: `Max results (default: ${cfg.topK})`,
-            }),
-          ),
-          userId: Type.Optional(
-            Type.String({
-              description:
-                "User ID to scope search (default: configured userId)",
-            }),
-          ),
-          scope: Type.Optional(
-            Type.Union([
-              Type.Literal("session"),
-              Type.Literal("long-term"),
-              Type.Literal("all"),
-            ], {
-              description:
-                'Memory scope: "session" (current session only), "long-term" (user-scoped only), or "all" (both). Default: "all"',
-            }),
-          ),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { query, limit, userId, scope = "all" } = params as {
-            query: string;
-            limit?: number;
-            userId?: string;
-            scope?: "session" | "long-term" | "all";
-          };
-
-          const [memoryResult, docResult] = await Promise.allSettled([
-            effectiveProvider.search(
-              query,
-              buildSearchOptions(effectiveCfg, userId, limit),
-            ),
-            effectiveProvider.searchDocuments(query, effectiveCfg.topK),
-          ]);
-
-          const sections: string[] = [];
-          let memoryCount = 0;
-          let docCount = 0;
-          let sanitizedMemories: { id: string; content: string; created_at: string }[] = [];
-
-          if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-            const results = memoryResult.value;
-            memoryCount = results.length;
-            const text = results
-              .map((r, i) => `${i + 1}. ${r.content} (id: ${r.id})`)
-              .join("\n");
-            sections.push(`## Memories\nFound ${results.length} memories:\n\n${text}`);
-            sanitizedMemories = results.map((r) => ({
-              id: r.id,
-              content: r.content,
-              created_at: r.created_at,
-            }));
-          } else if (memoryResult.status === "rejected") {
-            sections.push(`## Memories\nMemory search failed: ${String(memoryResult.reason)}`);
-          }
-
-          if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
-            docCount = docResult.value.results.length;
-            const context = buildDocumentContext(docResult.value.results);
-            sections.push(`## Documents\nFound ${docCount} document results:\n\n${context}`);
-          } else if (docResult.status === "rejected") {
-            sections.push(`## Documents\nDocument search failed: ${String(docResult.reason)}`);
-          }
-
-          if (memoryCount === 0 && docCount === 0) {
-            return {
-              content: [
-                { type: "text", text: "No relevant memories or documents found." },
-              ],
-              details: { count: 0 },
-            };
-          }
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: sections.join("\n\n"),
-              },
-            ],
-            details: {
-              memoryCount,
-              documentCount: docCount,
-              memories: sanitizedMemories,
-            },
-          };
-        },
-      }),
-      { name: "memory_search" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "memory_store",
-        label: "Memory Store",
-        description:
-          "Save important information in long-term memory via MemoryLake. Use for preferences, facts, decisions, and anything worth remembering.",
-        parameters: Type.Object({
-          text: Type.String({ description: "Information to remember" }),
-          userId: Type.Optional(
-            Type.String({
-              description: "User ID to scope this memory",
-            }),
-          ),
-          metadata: Type.Optional(
-            Type.Record(Type.String(), Type.Unknown(), {
-              description: "Optional metadata to attach to this memory",
-            }),
-          ),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { text, userId } = params as {
-            text: string;
-            userId?: string;
-            metadata?: Record<string, unknown>;
-          };
-
-          try {
-            const result = await effectiveProvider.add(
-              [{ role: "user", content: text }],
-              buildAddOptions(effectiveCfg, userId, (ctx as any)?.sessionId),
-            );
-
-            const count = result.results?.length ?? 0;
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: count > 0
-                    ? `Submitted ${count} memory task(s) for processing. ${result.results.map((r) => `[${r.status}] ${r.message}`).join("; ")}`
-                    : "No memories extracted.",
-                },
-              ],
-              details: {
-                action: "stored",
-                results: result.results,
-              },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory store failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "memory_store" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "memory_get",
-        label: "Memory Get",
-        description: "Retrieve a specific memory by its ID from MemoryLake.",
-        parameters: Type.Object({
-          memoryId: Type.String({ description: "The memory ID to retrieve" }),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { memoryId } = params as { memoryId: string };
-
-          try {
-            const memory = await effectiveProvider.get(memoryId);
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory ${memory.id}:\n${memory.content}\n\nCreated: ${memory.created_at ?? "unknown"}\nUpdated: ${memory.updated_at ?? "unknown"}`,
-                },
-              ],
-              details: { memory },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory get failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "memory_get" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "memory_list",
-        label: "Memory List",
-        description:
-          "List all stored memories for a user. Use this when you want to see everything that's been remembered, rather than searching for something specific.",
-        parameters: Type.Object({
-          userId: Type.Optional(
-            Type.String({
-              description:
-                "User ID to list memories for (default: configured userId)",
-            }),
-          ),
-          scope: Type.Optional(
-            Type.Union([
-              Type.Literal("session"),
-              Type.Literal("long-term"),
-              Type.Literal("all"),
-            ], {
-              description:
-                'Memory scope: "session" (current session only), "long-term" (user-scoped only), or "all" (both). Default: "all"',
-            }),
-          ),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { userId, scope = "all" } = params as { userId?: string; scope?: "session" | "long-term" | "all" };
-
-          try {
-            const uid = userId || effectiveCfg.userId;
-            const memories = await effectiveProvider.getAll({ user_id: uid });
-
-            if (!memories || memories.length === 0) {
-              return {
-                content: [
-                  { type: "text", text: "No memories stored yet." },
-                ],
-                details: { count: 0 },
-              };
-            }
-
-            const text = memories
-              .map(
-                (r, i) =>
-                  `${i + 1}. ${r.content} (id: ${r.id})`,
-              )
-              .join("\n");
-
-            const sanitized = memories.map((r) => ({
-              id: r.id,
-              content: r.content,
-              created_at: r.created_at,
-            }));
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `${memories.length} memories:\n\n${text}`,
-                },
-              ],
-              details: { count: memories.length, memories: sanitized },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory list failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "memory_list" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "memory_forget",
-        label: "Memory Forget",
-        description:
-          "Delete a specific memory by ID from MemoryLake.",
-        parameters: Type.Object({
-          memoryId: Type.String({ description: "Memory ID to delete" }),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { memoryId } = params as { memoryId: string };
-
-          try {
-            await effectiveProvider.delete(memoryId);
-            return {
-              content: [
-                { type: "text", text: `Memory ${memoryId} forgotten.` },
-              ],
-              details: { action: "deleted", id: memoryId },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory forget failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "memory_forget" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "document_search",
-        label: "Document Search",
-        description:
-          "Search through documents stored in MemoryLake project. Returns relevant paragraphs, tables, and figures from uploaded documents.",
-        parameters: Type.Object({
-          query: Type.String({ description: "Search query" }),
-          topN: Type.Optional(
-            Type.Number({
-              description: `Max results (default: ${cfg.topK})`,
-              minimum: 1,
-            }),
-          ),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { query, topN } = params as { query: string; topN?: number };
-
-          try {
-            const response = await effectiveProvider.searchDocuments(
-              query,
-              topN ?? effectiveCfg.topK,
-            );
-
-            if (!response.results || response.results.length === 0) {
-              return {
-                content: [
-                  { type: "text", text: "No relevant documents found." },
-                ],
-                details: { count: 0 },
-              };
-            }
-
-            const context = buildDocumentContext(response.results);
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Found ${response.results.length} document results:\n\n${context}`,
-                },
-              ],
-              details: { count: response.results.length },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Document search failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "document_search" },
-    );
-
-    /**
-     * Try to extract a usable filename from a pre-signed download URL.
-     * Returns null if the URL doesn't contain a recognizable filename.
-     */
-    function fileNameFromUrl(urlStr: string): string | null {
-      try {
-        const p = new URL(urlStr).pathname;
-        const base = path.posix.basename(p);
-        if (base && /\.\w{1,10}$/.test(base)) return decodeURIComponent(base);
-      } catch { /* ignore */ }
-      return null;
-    }
-
-    api.registerTool(
-      (ctx) => ({
-        name: "document_download",
-        label: "Document Download",
-        description:
-          "Download a document (image, PDF, etc.) from MemoryLake to local disk. After calling this tool, you MUST call the `message` tool with action='send' and media=<the returned local file path> to deliver the file to the user.",
-        parameters: Type.Object({
-          documentId: Type.String({
-            description:
-              "The document ID to download (from document_search results or document listing)",
-          }),
-          fileName: Type.Optional(
-            Type.String({
-              description:
-                "Original file name for saving locally (e.g. 'report.pdf'). Falls back to the name in the download URL or the document ID.",
-            }),
-          ),
-        }),
-        async execute(_toolCallId, params) {
-          const effectiveCfg = resolveConfig(ctx);
-          const effectiveProvider = getProvider(effectiveCfg);
-          const { documentId, fileName } = params as {
-            documentId: string;
-            fileName?: string;
-          };
-
-          try {
-            // 1. Get pre-signed download URL
-            const downloadUrl =
-              await effectiveProvider.getDocumentDownloadUrl(documentId);
-
-            // 2. Determine local save directory (cross-platform)
-            const workspaceDir = (ctx as any)?.workspaceDir;
-            const downloadDir = workspaceDir
-              ? path.join(workspaceDir, ".memorylake", "downloads")
-              : path.join(os.tmpdir(), "memorylake-downloads");
-            fs.mkdirSync(downloadDir, { recursive: true });
-
-            // 3. Determine filename: explicit param > URL-derived > documentId
-            const finalName =
-              fileName || fileNameFromUrl(downloadUrl) || documentId;
-            const localPath = path.join(downloadDir, finalName);
-
-            // 4. Stream download to local file
-            await pipeline(
-              got.stream(downloadUrl),
-              fs.createWriteStream(localPath),
-            );
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Document ${documentId} downloaded to:\n${localPath}\n\nYou MUST now call the message tool with action="send" and media set to this local path to deliver the file to the user.`,
-                },
-              ],
-              details: { documentId, localPath },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Document download failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { name: "document_download" },
-    );
-
-    api.registerTool(
-      (ctx) => ({
-        name: "advanced_web_search",
-        label: "Advanced Web Search",
-        description:
-          "Search the web using the unified search API with plugin-level domain and location constraints. Use this for recent information, public web pages, or web research that should respect configured allowed domains, blocked domains, and user locale.",
-        parameters: Type.Object({
-          query: Type.String({
-            description:
-              "The web search query to send to the unified search endpoint.",
-          }),
-          domain: Type.Optional(
-            Type.Union(
-              [
-                Type.Literal("web"),
-                Type.Literal("academic"),
-                Type.Literal("news"),
-                Type.Literal("people"),
-                Type.Literal("company"),
-                Type.Literal("financial"),
-                Type.Literal("markets"),
-                Type.Literal("code"),
-                Type.Literal("legal"),
-                Type.Literal("government"),
-                Type.Literal("poi"),
-                Type.Literal("auto"),
-              ],
-              {
-                description:
-                  "Search domain. Default: web. Invalid or unknown values are treated as auto.",
-              },
-            ),
-          ),
-          maxResults: Type.Optional(
-            Type.Number({
-              description: `Maximum number of web results to return (default: ${cfg.topK}).`,
-              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,
-            domain: rawDomain,
-            maxResults,
-            startDate,
-            endDate,
-          } = params as {
-            query: string;
-            domain?: string;
-            maxResults?: number;
-            startDate?: string;
-            endDate?: string;
-          };
-          const domain: WebSearchDomain =
-            rawDomain === undefined || rawDomain === null
-              ? "web"
-              : normalizeWebSearchDomain(rawDomain);
-
-          try {
-            const response = await effectiveProvider.searchWeb(query, {
-              domain,
-              max_results: maxResults ?? effectiveCfg.topK,
-              start_date: startDate,
-              end_date: endDate,
-              include_domains: effectiveCfg.webSearchIncludeDomains,
-              exclude_domains: effectiveCfg.webSearchExcludeDomains,
-              user_location:
-                effectiveCfg.webSearchCountry || effectiveCfg.webSearchTimezone
-                  ? {
-                    country: effectiveCfg.webSearchCountry,
-                    timezone: effectiveCfg.webSearchTimezone,
-                  }
-                  : undefined,
-            });
-
-            if (!response.results || response.results.length === 0) {
-              return {
-                content: [
-                  { type: "text", text: "No relevant web results found." },
-                ],
-                details: { count: 0, total_results: response.total_results },
-              };
-            }
-
-            const context = buildWebSearchContext(response.results);
-
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Found ${response.results.length} web results:\n\n${context}`,
-                },
-              ],
-              details: {
-                count: response.results.length,
-                total_results: response.total_results,
-                results: response.results,
-              },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Web search failed: ${String(err)}`,
-                },
-              ],
-              details: { error: String(err) },
-            };
-          }
-        },
-      }),
-      { 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) },
-            };
-          }
-        },
-      }),
-    );
-
-    // ========================================================================
-    // CLI Commands
-    // ========================================================================
-
-    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 = JSON.parse(fs.readFileSync(openclawPath, "utf-8"));
-                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"] },
-    );
-
-    // ========================================================================
-    // Lifecycle Hooks
-    // ========================================================================
-
-    // --- Auto-upload helpers ---
-    const UPLOADED_RECORD_FILE = "uploaded.json";
-
-    type UploadedRecord = Record<string, { mtimeMs: number }>;
-
-    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 (err) {
-        api.logger.warn(`memorylake-openclaw: failed to read uploaded record: ${String(err)}`);
-      }
-      return {};
-    }
-
-    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),
-      );
-    }
-
-    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;
-    }
-
-    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)];
-    }
-
-    // Auto-upload: upload inbound files to MemoryLake before prompt build
-    if (cfg.autoUpload) {
-      // Lazy-load upload function from upload.mjs
-      let uploadAutoFn: UploadFn | 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;
-
-        const effectiveCfg = resolveConfig(ctx);
-        const paths = extractInboundPaths(event.prompt);
-        if (paths.length === 0) return;
-
-        const record = getUploadedRecord(workspaceDir);
-        const filesToUpload: { filePath: string; stat: fs.Stats }[] = [];
-        for (const p of paths) {
-          const stat = needsUpload(record, p);
-          if (stat) filesToUpload.push({ filePath: p, stat });
-        }
-        if (filesToUpload.length === 0) return;
-
-        // Fire-and-forget: upload asynchronously without blocking
-        (async () => {
-          // Lazy import upload.mjs
-          if (!uploadAutoFn) {
-            const uploadModule = await import(
-              /* webpackIgnore: true */
-              new URL("./skills/memorylake-upload/scripts/upload.mjs", import.meta.url).href
-            );
-            uploadAutoFn = uploadModule.uploadAuto;
-          }
-
-          for (const { filePath, stat } of filesToUpload) {
-            try {
-              await uploadAutoFn!({
-                host: effectiveCfg.host,
-                apiKey: effectiveCfg.apiKey,
-                projectId: effectiveCfg.projectId,
-                filePath,
-                fileName: path.basename(filePath),
-              });
-              // Save record only after successful upload to avoid race on crash
-              const current = getUploadedRecord(workspaceDir);
-              current[filePath] = { mtimeMs: stat.mtimeMs };
-              saveUploadedRecord(workspaceDir, current);
-              api.logger.info(
-                `memorylake-openclaw: auto-uploaded ${path.basename(filePath)}`,
-              );
-            } catch (err) {
-              api.logger.warn(
-                `memorylake-openclaw: auto-upload failed for ${filePath}: ${String(err)}`,
-              );
-            }
-          }
-        })().catch((err) => {
-          api.logger.warn(
-            `memorylake-openclaw: auto-upload unexpected error: ${String(err)}`,
-          );
-        });
-      });
-    }
-
-    // ------------------------------------------------------------------
-    // 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 system-level memory instructions and open data
-    // categories before prompt build.  Memory content is NOT pre-fetched;
-    // the model is instructed to call memory_search itself.
-    // ------------------------------------------------------------------
-    if (cfg.autoRecall) {
-      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;
-
-        const effectiveCfg = resolveConfig(ctx);
-        const effectiveProvider = getProvider(effectiveCfg);
-
-        const sessionId = (ctx as any)?.sessionId ?? undefined;
-
-        // 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 result: { prependSystemContext?: string; appendSystemContext?: string } = {};
-
-        const memoryDirectiveParts: string[] = [
-          `<memory-instructions>`,
-          `You have access to the user's long-term memory AND documents via MemoryLake (memory_search tool).`,
-          `The memory_search tool searches both memories and uploaded documents in a single call.`,
-          ``,
-          `MANDATORY PROCEDURE for EVERY user message:`,
-          `1. Read the user's message.`,
-          `2. Call memory_search with a query derived from the message — this step is NOT optional.`,
-          `3. Use the search results (memories + documents) to personalize your response.`,
-          `4. Respond to the user.`,
-          ``,
-          `This applies to ALL messages — greetings, recommendations, advice, casual chat, tasks, questions.`,
-          `The user's preferences, history, name, hobbies, context, and documents are stored in MemoryLake.`,
-          `A response without memory_search is INCORRECT because it ignores personalized context.`,
-          `</memory-instructions>`,
-        ];
-        result.prependSystemContext = memoryDirectiveParts.join("\n");
-
-        const appendParts: string[] = [];
-        if (industries && industries.length > 0) {
-          const categoryList = industries
-            .map((ind) => `- ${ind.id}: ${ind.name}${ind.description ? ` — ${ind.description}` : ""}`)
-            .join("\n");
-          appendParts.push(
-            `<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 (appendParts.length > 0) {
-          result.appendSystemContext = appendParts.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;
-        }
-
-        // 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 (!textContent) continue;
-            // Strip injected context, keep the actual user text
-            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({
-              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)}`);
-        }
-      });
-    }
-
-    // ========================================================================
-    // Service
-    // ========================================================================
+    registerMemoryTools(pctx, cfg);
+    registerDocumentTools(pctx);
+    registerSearchTools(pctx, cfg);
+    registerCli(pctx, cfg);
+    if (cfg.autoUpload) registerAutoUpload(pctx);
+    if (cfg.autoRecall) registerAutoRecall(pctx);
+    if (cfg.autoCapture) registerAutoCapture(pctx);
 
     api.registerService({
       id: "memorylake-openclaw",