@xdarkicex/openclaw-memory-libravdb 1.4.46 → 1.4.48

package/dist/index.js

@@ -34419,824 +34419,324 @@ function isRecord(value) {
 import fs2 from "node:fs";
 import fsp2 from "node:fs/promises";
 import path2 from "node:path";
-var DEFAULT_DEBOUNCE_MS2 = 150;
-var DEFAULT_TOKENIZER_ID = "markdown-ingest:v1";
-var MARKDOWN_INGEST_VERSION = 3;
-var HASH_BACKEND = "wasm-fnv1a64";
-function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsApi = createRealFsApi2()) {
-  const adapters = [];
-  const genericRoots = normalizeMarkdownRoots(cfg.markdownIngestionRoots);
-  if (isMarkdownIngestionEnabled(cfg, genericRoots)) {
-    adapters.push(
-      new DirectoryMarkdownSourceAdapter(
-        "generic",
-        {
-          roots: genericRoots,
-          include: cfg.markdownIngestionInclude,
-          exclude: cfg.markdownIngestionExclude,
-          debounceMs: cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS2
-        },
-        getRpc,
-        logger,
-        fsApi
-      )
-    );
+
+// node_modules/.pnpm/@bufbuild+protobuf@1.7.2/node_modules/@bufbuild/protobuf/dist/proxy/index.js
+var proxy_exports = {};
+__reExport(proxy_exports, __toESM(require_cjs(), 1));
+
+// node_modules/.pnpm/@xdarkicex+libravdb-contracts@0.0.6/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_pb.js
+var IngestMode;
+(function(IngestMode2) {
+  IngestMode2[IngestMode2["REPLACE"] = 0] = "REPLACE";
+  IngestMode2[IngestMode2["APPEND"] = 1] = "APPEND";
+})(IngestMode || (IngestMode = {}));
+proxy_exports.proto3.util.setEnumType(IngestMode, "libravdb.ipc.v1.IngestMode", [
+  { no: 0, name: "INGEST_MODE_REPLACE" },
+  { no: 1, name: "INGEST_MODE_APPEND" }
+]);
+var RpcRequest = class _RpcRequest extends proxy_exports.Message {
+  /**
+   * @generated from field: uint64 id = 1;
+   */
+  id = proxy_exports.protoInt64.zero;
+  /**
+   * @generated from field: string method = 2;
+   */
+  method = "";
+  /**
+   * @generated from field: bytes params = 3;
+   */
+  params = new Uint8Array(0);
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
   }
-  const obsidianRoots = normalizeMarkdownRoots(cfg.markdownIngestionObsidianRoots);
-  if (cfg.markdownIngestionObsidianEnabled !== false && obsidianRoots.length > 0) {
-    adapters.push(
-      new DirectoryMarkdownSourceAdapter(
-        "obsidian",
-        {
-          roots: obsidianRoots,
-          include: cfg.markdownIngestionObsidianInclude,
-          exclude: cfg.markdownIngestionObsidianExclude,
-          debounceMs: cfg.markdownIngestionObsidianDebounceMs ?? cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS2
-        },
-        getRpc,
-        logger,
-        fsApi
-      )
-    );
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RpcRequest";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "id",
+      kind: "scalar",
+      T: 4
+      /* ScalarType.UINT64 */
+    },
+    {
+      no: 2,
+      name: "method",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    {
+      no: 3,
+      name: "params",
+      kind: "scalar",
+      T: 12
+      /* ScalarType.BYTES */
+    }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RpcRequest().fromBinary(bytes, options);
   }
-  if (adapters.length === 0) {
-    return {
-      async start() {
-      },
-      async refresh() {
-      },
-      async stop() {
-      }
-    };
+  static fromJson(jsonValue, options) {
+    return new _RpcRequest().fromJson(jsonValue, options);
   }
-  const adapter = new CompositeMarkdownSourceAdapter(adapters);
-  return {
-    start: () => adapter.start(),
-    refresh: () => adapter.refresh(),
-    stop: () => adapter.stop()
-  };
-}
-var CompositeMarkdownSourceAdapter = class {
-  constructor(adapters) {
-    this.adapters = adapters;
+  static fromJsonString(jsonString, options) {
+    return new _RpcRequest().fromJsonString(jsonString, options);
   }
-  adapters;
-  kind = "composite";
-  async start() {
-    for (const adapter of this.adapters) {
-      await adapter.start();
-    }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RpcRequest, a, b);
   }
-  async refresh() {
-    for (const adapter of this.adapters) {
-      await adapter.refresh();
-    }
+};
+var RpcResponse = class _RpcResponse extends proxy_exports.Message {
+  /**
+   * @generated from field: uint64 id = 1;
+   */
+  id = proxy_exports.protoInt64.zero;
+  /**
+   * @generated from field: bytes result = 2;
+   */
+  result = new Uint8Array(0);
+  /**
+   * @generated from field: libravdb.ipc.v1.RpcError error = 3;
+   */
+  error;
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
   }
-  async stop() {
-    for (const adapter of this.adapters) {
-      await adapter.stop();
-    }
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RpcResponse";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "id",
+      kind: "scalar",
+      T: 4
+      /* ScalarType.UINT64 */
+    },
+    {
+      no: 2,
+      name: "result",
+      kind: "scalar",
+      T: 12
+      /* ScalarType.BYTES */
+    },
+    { no: 3, name: "error", kind: "message", T: RpcError }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RpcResponse().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _RpcResponse().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _RpcResponse().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RpcResponse, a, b);
   }
 };
-var DirectoryMarkdownSourceAdapter = class {
-  kind;
-  roots;
-  includePatterns;
-  excludePatterns;
-  debounceMs;
-  fsApi;
-  getRpc;
-  logger;
-  states = /* @__PURE__ */ new Map();
-  fileStates = /* @__PURE__ */ new Map();
-  activeScans = /* @__PURE__ */ new Set();
-  tokenizerId;
-  coreDoc;
-  started = false;
-  stopping = false;
-  constructor(kind, config, getRpc, logger, fsApi) {
-    this.kind = kind;
-    this.roots = config.roots;
-    this.includePatterns = config.include?.length ? config.include : [];
-    this.excludePatterns = config.exclude?.length ? config.exclude : [];
-    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS2;
-    this.fsApi = fsApi;
-    this.getRpc = getRpc;
-    this.logger = logger;
-    this.tokenizerId = DEFAULT_TOKENIZER_ID;
-    this.coreDoc = true;
+var RpcError = class _RpcError extends proxy_exports.Message {
+  /**
+   * @generated from field: string message = 1;
+   */
+  message = "";
+  /**
+   * @generated from field: int32 code = 2;
+   */
+  code = 0;
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
   }
-  async start() {
-    if (this.started) {
-      return;
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RpcError";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "message",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    {
+      no: 2,
+      name: "code",
+      kind: "scalar",
+      T: 5
+      /* ScalarType.INT32 */
     }
-    this.started = true;
-    this.stopping = false;
-    await this.refresh();
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RpcError().fromBinary(bytes, options);
   }
-  async refresh() {
-    if (!this.started || this.stopping) {
-      return;
-    }
-    for (const root of this.roots) {
-      await this.scanRoot(root);
-    }
+  static fromJson(jsonValue, options) {
+    return new _RpcError().fromJson(jsonValue, options);
   }
-  async stop() {
-    this.stopping = true;
-    for (const state of this.states.values()) {
-      if (state.scanState.timer) {
-        clearTimeout(state.scanState.timer);
-        state.scanState.timer = null;
-      }
-      for (const watcher of state.directoryWatchers.values()) {
-        watcher.close();
-      }
-      state.directoryWatchers.clear();
-    }
-    if (this.activeScans.size > 0) {
-      await Promise.allSettled([...this.activeScans]);
-    }
-    this.states.clear();
-    this.fileStates.clear();
-    this.started = false;
+  static fromJsonString(jsonString, options) {
+    return new _RpcError().fromJsonString(jsonString, options);
   }
-  getRootState(root) {
-    const resolved = path2.resolve(root);
-    const existing = this.states.get(resolved);
-    if (existing) {
-      return existing;
-    }
-    const created = {
-      root: resolved,
-      scanState: {
-        scanning: false,
-        dirty: false,
-        timer: null
-      },
-      knownFiles: /* @__PURE__ */ new Set(),
-      directoryWatchers: /* @__PURE__ */ new Map()
-    };
-    this.states.set(resolved, created);
-    return created;
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RpcError, a, b);
   }
-  async scanRoot(root) {
-    if (!this.started || this.stopping) {
-      return;
-    }
-    const rootState = this.getRootState(root);
-    if (rootState.scanState.scanning) {
-      rootState.scanState.dirty = true;
-      return;
-    }
-    rootState.scanState.scanning = true;
-    const scan = (async () => {
-      try {
-        const currentFiles = /* @__PURE__ */ new Set();
-        await this.walkDirectory(rootState, rootState.root, currentFiles);
-        if (!this.stopping) {
-          await this.pruneDeletedFiles(rootState, currentFiles);
-          rootState.knownFiles = currentFiles;
-        }
-      } finally {
-        rootState.scanState.scanning = false;
-        if (rootState.scanState.dirty) {
-          rootState.scanState.dirty = false;
-          if (!this.stopping) {
-            this.scheduleRootScan(rootState);
-          }
-        }
-      }
-    })();
-    this.activeScans.add(scan);
-    try {
-      await scan;
-    } finally {
-      this.activeScans.delete(scan);
-    }
+};
+var StringList = class _StringList extends proxy_exports.Message {
+  /**
+   * @generated from field: repeated string values = 1;
+   */
+  values = [];
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
   }
-  scheduleRootScan(rootState) {
-    if (!this.started || this.stopping) {
-      return;
-    }
-    if (rootState.scanState.scanning) {
-      rootState.scanState.dirty = true;
-      return;
-    }
-    if (rootState.scanState.timer) {
-      return;
-    }
-    rootState.scanState.timer = setTimeout(() => {
-      rootState.scanState.timer = null;
-      void this.scanRoot(rootState.root).catch((error) => {
-        this.logger.warn?.(`[markdown-ingest] root scan failed for ${rootState.root}: ${formatError(error)}`);
-      });
-    }, this.debounceMs);
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.StringList";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    { no: 1, name: "values", kind: "scalar", T: 9, repeated: true }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _StringList().fromBinary(bytes, options);
   }
-  async walkDirectory(rootState, dir, currentFiles) {
-    await this.ensureDirectoryWatcher(rootState, dir);
-    let entries;
-    try {
-      entries = await this.fsApi.readdir(dir);
-    } catch (error) {
-      const message = formatError(error);
-      if (!message.includes("ENOENT")) {
-        this.logger.warn?.(`[markdown-ingest] readdir failed for ${dir}: ${message}`);
-      }
-      return;
-    }
-    for (const entry of entries) {
-      if (this.stopping) {
-        return;
-      }
-      const child = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await this.walkDirectory(rootState, child, currentFiles);
-        continue;
-      }
-      if (!entry.isFile() || !isMarkdownFile(entry.name)) {
-        continue;
-      }
-      if (!this.shouldIncludeFile(rootState.root, child)) {
-        continue;
-      }
-      currentFiles.add(child);
-      try {
-        await this.syncMarkdownFile(rootState, child);
-      } catch (error) {
-        if (!this.stopping) {
-          this.logger.warn?.(`[markdown-ingest] sync failed for ${child}: ${formatError(error)}`);
-        }
-      }
-    }
+  static fromJson(jsonValue, options) {
+    return new _StringList().fromJson(jsonValue, options);
   }
-  async ensureDirectoryWatcher(rootState, dir) {
-    if (rootState.directoryWatchers.has(dir)) {
-      return;
-    }
-    try {
-      const watcher = this.fsApi.watch(dir, () => {
-        if (!this.stopping) {
-          this.scheduleRootScan(rootState);
-        }
-      });
-      watcher.on("error", (error) => {
-        this.logger.warn?.(`[markdown-ingest] watch error for ${dir}: ${formatError(error)}`);
-      });
-      rootState.directoryWatchers.set(dir, watcher);
-    } catch (error) {
-      this.logger.warn?.(`[markdown-ingest] watch unavailable for ${dir}: ${formatError(error)}`);
-    }
+  static fromJsonString(jsonString, options) {
+    return new _StringList().fromJsonString(jsonString, options);
   }
-  shouldIncludeFile(root, filePath) {
-    if (isOpenClawMemoryFile(filePath)) {
-      return true;
-    }
-    const relative = toPosixPath(path2.relative(root, filePath));
-    if (this.excludePatterns.length > 0) {
-      for (const pattern of this.excludePatterns) {
-        if (matchesGlob(relative, pattern)) {
-          return false;
-        }
-      }
-    }
-    if (this.includePatterns.length > 0) {
-      for (const pattern of this.includePatterns) {
-        if (matchesGlob(relative, pattern)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    return true;
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_StringList, a, b);
   }
-  async pruneDeletedFiles(rootState, currentFiles) {
-    const removed = [];
-    for (const previous of rootState.knownFiles) {
-      if (!currentFiles.has(previous)) {
-        removed.push(previous);
-      }
-    }
-    if (removed.length === 0) {
-      return;
-    }
-    for (const filePath of removed) {
-      await this.deleteSourceDocument(filePath);
-      this.fileStates.delete(filePath);
-    }
+};
+var SearchResult = class _SearchResult extends proxy_exports.Message {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = "";
+  /**
+   * @generated from field: double score = 2;
+   */
+  score = 0;
+  /**
+   * @generated from field: string text = 3;
+   */
+  text = "";
+  /**
+   * @generated from field: google.protobuf.Struct metadata = 4;
+   */
+  metadata;
+  /**
+   * @generated from field: uint64 version = 5;
+   */
+  version = proxy_exports.protoInt64.zero;
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
   }
-  async syncMarkdownFile(rootState, filePath) {
-    const sourceDoc = filePath;
-    const relativePath = toPosixPath(path2.relative(rootState.root, filePath));
-    const stat = await this.safeStat(filePath);
-    if (!stat) {
-      await this.deleteSourceDocument(sourceDoc);
-      this.fileStates.delete(sourceDoc);
-      return;
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.SearchResult";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "id",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    {
+      no: 2,
+      name: "score",
+      kind: "scalar",
+      T: 1
+      /* ScalarType.DOUBLE */
+    },
+    {
+      no: 3,
+      name: "text",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    { no: 4, name: "metadata", kind: "message", T: proxy_exports.Struct },
+    {
+      no: 5,
+      name: "version",
+      kind: "scalar",
+      T: 4
+      /* ScalarType.UINT64 */
     }
-    const cached = this.fileStates.get(sourceDoc);
-    if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
-      return;
-    }
-    const bytes = await this.safeReadFile(filePath);
-    if (!bytes) {
-      await this.deleteSourceDocument(sourceDoc);
-      this.fileStates.delete(sourceDoc);
-      return;
-    }
-    const fileHash = hashBytes(bytes);
-    if (cached && cached.fileHash === fileHash) {
-      this.fileStates.set(sourceDoc, {
-        root: rootState.root,
-        sourceDoc,
-        relativePath,
-        fileHash,
-        size: stat.size,
-        mtimeMs: stat.mtimeMs
-      });
-      return;
-    }
-    const text = textDecoder2.decode(bytes);
-    if (this.kind === "obsidian" && this.includePatterns.length === 0 && !looksLikeObsidianNote(filePath, text)) {
-      await this.deleteSourceDocument(sourceDoc);
-      this.fileStates.delete(sourceDoc);
-      return;
-    }
-    await this.ingestMarkdownDocument(sourceDoc, text, rootState.root, relativePath, fileHash, stat.size, stat.mtimeMs);
-    this.fileStates.set(sourceDoc, {
-      root: rootState.root,
-      sourceDoc,
-      relativePath,
-      fileHash,
-      size: stat.size,
-      mtimeMs: stat.mtimeMs
-    });
-  }
-  async ingestMarkdownDocument(sourceDoc, text, sourceRoot, sourcePath, fileHash, sourceSize, sourceMtimeMs) {
-    const rpc = await this.getRpc();
-    const params = {
-      sourceDoc,
-      text,
-      tokenizerId: this.tokenizerId,
-      coreDoc: this.coreDoc,
-      sourceMeta: {
-        sourceRoot,
-        sourcePath,
-        sourceKind: this.kind,
-        fileHash,
-        sourceSize,
-        sourceMtimeMs: Math.trunc(sourceMtimeMs),
-        ingestVersion: MARKDOWN_INGEST_VERSION,
-        hashBackend: HASH_BACKEND
-      }
-    };
-    await rpc.call("ingest_markdown_document", params);
+  ]);
+  static fromBinary(bytes, options) {
+    return new _SearchResult().fromBinary(bytes, options);
   }
-  async deleteSourceDocument(sourceDoc) {
-    const rpc = await this.getRpc();
-    const params = { sourceDoc };
-    await rpc.call("delete_authored_document", params);
+  static fromJson(jsonValue, options) {
+    return new _SearchResult().fromJson(jsonValue, options);
   }
-  async safeStat(filePath) {
-    try {
-      return await this.fsApi.stat(filePath);
-    } catch {
-      return null;
-    }
+  static fromJsonString(jsonString, options) {
+    return new _SearchResult().fromJsonString(jsonString, options);
   }
-  async safeReadFile(filePath) {
-    try {
-      return await this.fsApi.readFile(filePath);
-    } catch {
-      return null;
-    }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_SearchResult, a, b);
   }
 };
-function toPosixPath(value) {
-  return value.split(path2.sep).join("/");
-}
-var textDecoder2 = new TextDecoder();
-function normalizeMarkdownRoots(roots) {
-  if (!roots?.length) {
-    return [];
-  }
-  const resolved = /* @__PURE__ */ new Set();
-  for (const root of roots) {
-    const trimmed = root.trim();
-    if (!trimmed) {
-      continue;
-    }
-    resolved.add(path2.resolve(trimmed));
-  }
-  return [...resolved];
-}
-function isMarkdownIngestionEnabled(cfg, roots) {
-  if (cfg.markdownIngestionEnabled === false) {
-    return false;
-  }
-  return roots.length > 0;
-}
-function createRealFsApi2() {
-  return {
-    readdir: async (dir) => fsp2.readdir(dir, { withFileTypes: true }),
-    readFile: async (file) => fsp2.readFile(file),
-    stat: async (file) => {
-      const stat = await fsp2.stat(file);
-      return { size: stat.size, mtimeMs: stat.mtimeMs };
-    },
-    watch: (dir, onChange) => fs2.watch(dir, onChange)
-  };
-}
-function isMarkdownFile(fileName) {
-  const lower = fileName.toLowerCase();
-  return lower.endsWith(".md") || lower.endsWith(".markdown");
-}
-function matchesGlob(value, pattern) {
-  const escaped = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
-  return new RegExp(`^${escaped}$`).test(value);
-}
-function looksLikeObsidianNote(filePath, text) {
-  if (!text.startsWith("---\n")) {
-    return hasInlineObsidianTag(text);
-  }
-  const frontmatterEnd = findFrontmatterEnd(text, 4);
-  if (frontmatterEnd < 0) {
-    return hasInlineObsidianTag(text);
-  }
-  const frontmatter = text.slice(4, frontmatterEnd);
-  const lines = frontmatter.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trimStart();
-    if (trimmed.startsWith("tags:") || trimmed.startsWith("tag:") || trimmed.startsWith("openclaw:") || trimmed.startsWith("memory:")) {
-      return true;
-    }
-  }
-  return hasInlineObsidianTag(text.slice(frontmatterEnd + 4));
-}
-function findFrontmatterEnd(text, offset) {
-  for (let i = offset; i < text.length - 3; i++) {
-    if (text.charCodeAt(i) !== 45 || text.charCodeAt(i + 1) !== 45 || text.charCodeAt(i + 2) !== 45) {
-      continue;
-    }
-    const next = text.charCodeAt(i + 3);
-    if (next === 10) {
-      return i;
-    }
-    if (next === 13 && text.charCodeAt(i + 4) === 10) {
-      return i;
-    }
-  }
-  return -1;
-}
-function hasInlineObsidianTag(text) {
-  let inFence = false;
-  const lines = text.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trimStart();
-    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) {
-      continue;
-    }
-    if (trimmed.startsWith("#")) {
-      continue;
-    }
-    if (/(^|[^A-Za-z0-9_])#([A-Za-z][A-Za-z0-9/_-]*)\b/.test(line)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isOpenClawMemoryFile(filePath) {
-  return path2.basename(filePath).toLowerCase() === "memory.md";
-}
-
-// src/memory-provider.ts
-var MEMORY_PROMPT_HEADER = [
-  "## Memory",
-  "LibraVDB persistent memory is configured. Recalled memories may appear",
-  "in context via the context-engine assembler when available and relevant.",
-  ""
-];
-function buildMemoryPromptSection(_getRpc, _cfg) {
-  return function memoryPromptSection({
-    availableTools: _availableTools,
-    citationsMode: _citationsMode
-  }) {
-    return [...MEMORY_PROMPT_HEADER];
-  };
-}
-
-// node_modules/.pnpm/@bufbuild+protobuf@1.7.2/node_modules/@bufbuild/protobuf/dist/proxy/index.js
-var proxy_exports = {};
-__reExport(proxy_exports, __toESM(require_cjs(), 1));
-
-// node_modules/.pnpm/@xdarkicex+libravdb-contracts@0.0.1/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_pb.js
-var RpcRequest = class _RpcRequest extends proxy_exports.Message {
+var MarkdownSourceMeta = class _MarkdownSourceMeta extends proxy_exports.Message {
   /**
-   * @generated from field: uint64 id = 1;
+   * @generated from field: string source_root = 1;
    */
-  id = proxy_exports.protoInt64.zero;
+  sourceRoot = "";
   /**
-   * @generated from field: string method = 2;
+   * @generated from field: string source_path = 2;
    */
-  method = "";
+  sourcePath = "";
   /**
-   * @generated from field: bytes params = 3;
+   * @generated from field: string source_kind = 3;
    */
-  params = new Uint8Array(0);
+  sourceKind = "";
+  /**
+   * @generated from field: string file_hash = 4;
+   */
+  fileHash = "";
+  /**
+   * @generated from field: int64 source_size = 5;
+   */
+  sourceSize = proxy_exports.protoInt64.zero;
+  /**
+   * @generated from field: int64 source_mtime_ms = 6;
+   */
+  sourceMtimeMs = proxy_exports.protoInt64.zero;
+  /**
+   * @generated from field: int32 ingest_version = 7;
+   */
+  ingestVersion = 0;
+  /**
+   * @generated from field: string hash_backend = 8;
+   */
+  hashBackend = "";
   constructor(data) {
     super();
     proxy_exports.proto3.util.initPartial(data, this);
   }
   static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RpcRequest";
+  static typeName = "libravdb.ipc.v1.MarkdownSourceMeta";
   static fields = proxy_exports.proto3.util.newFieldList(() => [
     {
       no: 1,
-      name: "id",
+      name: "source_root",
       kind: "scalar",
-      T: 4
-      /* ScalarType.UINT64 */
+      T: 9
+      /* ScalarType.STRING */
     },
     {
       no: 2,
-      name: "method",
+      name: "source_path",
       kind: "scalar",
       T: 9
       /* ScalarType.STRING */
     },
     {
       no: 3,
-      name: "params",
-      kind: "scalar",
-      T: 12
-      /* ScalarType.BYTES */
-    }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RpcRequest().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _RpcRequest().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _RpcRequest().fromJsonString(jsonString, options);
-  }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RpcRequest, a, b);
-  }
-};
-var RpcResponse = class _RpcResponse extends proxy_exports.Message {
-  /**
-   * @generated from field: uint64 id = 1;
-   */
-  id = proxy_exports.protoInt64.zero;
-  /**
-   * @generated from field: bytes result = 2;
-   */
-  result = new Uint8Array(0);
-  /**
-   * @generated from field: libravdb.ipc.v1.RpcError error = 3;
-   */
-  error;
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RpcResponse";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "id",
-      kind: "scalar",
-      T: 4
-      /* ScalarType.UINT64 */
-    },
-    {
-      no: 2,
-      name: "result",
-      kind: "scalar",
-      T: 12
-      /* ScalarType.BYTES */
-    },
-    { no: 3, name: "error", kind: "message", T: RpcError }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RpcResponse().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _RpcResponse().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _RpcResponse().fromJsonString(jsonString, options);
-  }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RpcResponse, a, b);
-  }
-};
-var RpcError = class _RpcError extends proxy_exports.Message {
-  /**
-   * @generated from field: string message = 1;
-   */
-  message = "";
-  /**
-   * @generated from field: int32 code = 2;
-   */
-  code = 0;
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RpcError";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "message",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    {
-      no: 2,
-      name: "code",
-      kind: "scalar",
-      T: 5
-      /* ScalarType.INT32 */
-    }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RpcError().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _RpcError().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _RpcError().fromJsonString(jsonString, options);
-  }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RpcError, a, b);
-  }
-};
-var StringList = class _StringList extends proxy_exports.Message {
-  /**
-   * @generated from field: repeated string values = 1;
-   */
-  values = [];
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.StringList";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    { no: 1, name: "values", kind: "scalar", T: 9, repeated: true }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _StringList().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _StringList().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _StringList().fromJsonString(jsonString, options);
-  }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_StringList, a, b);
-  }
-};
-var SearchResult = class _SearchResult extends proxy_exports.Message {
-  /**
-   * @generated from field: string id = 1;
-   */
-  id = "";
-  /**
-   * @generated from field: double score = 2;
-   */
-  score = 0;
-  /**
-   * @generated from field: string text = 3;
-   */
-  text = "";
-  /**
-   * @generated from field: google.protobuf.Struct metadata = 4;
-   */
-  metadata;
-  /**
-   * @generated from field: uint64 version = 5;
-   */
-  version = proxy_exports.protoInt64.zero;
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.SearchResult";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "id",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    {
-      no: 2,
-      name: "score",
-      kind: "scalar",
-      T: 1
-      /* ScalarType.DOUBLE */
-    },
-    {
-      no: 3,
-      name: "text",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    { no: 4, name: "metadata", kind: "message", T: proxy_exports.Struct },
-    {
-      no: 5,
-      name: "version",
-      kind: "scalar",
-      T: 4
-      /* ScalarType.UINT64 */
-    }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _SearchResult().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _SearchResult().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _SearchResult().fromJsonString(jsonString, options);
-  }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_SearchResult, a, b);
-  }
-};
-var MarkdownSourceMeta = class _MarkdownSourceMeta extends proxy_exports.Message {
-  /**
-   * @generated from field: string source_root = 1;
-   */
-  sourceRoot = "";
-  /**
-   * @generated from field: string source_path = 2;
-   */
-  sourcePath = "";
-  /**
-   * @generated from field: string source_kind = 3;
-   */
-  sourceKind = "";
-  /**
-   * @generated from field: string file_hash = 4;
-   */
-  fileHash = "";
-  /**
-   * @generated from field: int64 source_size = 5;
-   */
-  sourceSize = proxy_exports.protoInt64.zero;
-  /**
-   * @generated from field: int64 source_mtime_ms = 6;
-   */
-  sourceMtimeMs = proxy_exports.protoInt64.zero;
-  /**
-   * @generated from field: int32 ingest_version = 7;
-   */
-  ingestVersion = 0;
-  /**
-   * @generated from field: string hash_backend = 8;
-   */
-  hashBackend = "";
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.MarkdownSourceMeta";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "source_root",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    {
-      no: 2,
-      name: "source_path",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    {
-      no: 3,
-      name: "source_kind",
+      name: "source_kind",
       kind: "scalar",
       T: 9
       /* ScalarType.STRING */
@@ -36512,6 +36012,12 @@ var IngestMarkdownDocumentRequest = class _IngestMarkdownDocumentRequest extends
    * @generated from field: libravdb.ipc.v1.MarkdownSourceMeta source_meta = 5;
    */
   sourceMeta;
+  /**
+   * default INGEST_MODE_REPLACE if absent
+   *
+   * @generated from field: libravdb.ipc.v1.IngestMode mode = 6;
+   */
+  mode = IngestMode.REPLACE;
   constructor(data) {
     super();
     proxy_exports.proto3.util.initPartial(data, this);
@@ -36547,7 +36053,8 @@ var IngestMarkdownDocumentRequest = class _IngestMarkdownDocumentRequest extends
       T: 8
       /* ScalarType.BOOL */
     },
-    { no: 5, name: "source_meta", kind: "message", T: MarkdownSourceMeta }
+    { no: 5, name: "source_meta", kind: "message", T: MarkdownSourceMeta },
+    { no: 6, name: "mode", kind: "enum", T: proxy_exports.proto3.getEnumType(IngestMode) }
   ]);
   static fromBinary(bytes, options) {
     return new _IngestMarkdownDocumentRequest().fromBinary(bytes, options);
@@ -38592,132 +38099,781 @@ var RankCandidatesRequest = class _RankCandidatesRequest extends proxy_exports.M
   static equals(a, b) {
     return proxy_exports.proto3.util.equals(_RankCandidatesRequest, a, b);
   }
-};
-var RankCandidatesResponse = class _RankCandidatesResponse extends proxy_exports.Message {
-  /**
-   * @generated from field: repeated libravdb.ipc.v1.RankCandidate ranked = 1;
-   */
-  ranked = [];
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
+};
+var RankCandidatesResponse = class _RankCandidatesResponse extends proxy_exports.Message {
+  /**
+   * @generated from field: repeated libravdb.ipc.v1.RankCandidate ranked = 1;
+   */
+  ranked = [];
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
+  }
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RankCandidatesResponse";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    { no: 1, name: "ranked", kind: "message", T: RankCandidate, repeated: true }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RankCandidatesResponse().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _RankCandidatesResponse().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _RankCandidatesResponse().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RankCandidatesResponse, a, b);
+  }
+};
+var RebuildIndexRequest = class _RebuildIndexRequest extends proxy_exports.Message {
+  /**
+   * @generated from field: string namespace = 1;
+   */
+  namespace = "";
+  /**
+   * @generated from field: repeated string collections = 2;
+   */
+  collections = [];
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
+  }
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RebuildIndexRequest";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "namespace",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    { no: 2, name: "collections", kind: "scalar", T: 9, repeated: true }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RebuildIndexRequest().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _RebuildIndexRequest().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _RebuildIndexRequest().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RebuildIndexRequest, a, b);
+  }
+};
+var RebuildIndexResponse = class _RebuildIndexResponse extends proxy_exports.Message {
+  /**
+   * @generated from field: int32 collections_processed = 1;
+   */
+  collectionsProcessed = 0;
+  /**
+   * @generated from field: int32 records_reindexed = 2;
+   */
+  recordsReindexed = 0;
+  /**
+   * @generated from field: int32 collections_recreated = 3;
+   */
+  collectionsRecreated = 0;
+  /**
+   * @generated from field: repeated string errors = 4;
+   */
+  errors = [];
+  constructor(data) {
+    super();
+    proxy_exports.proto3.util.initPartial(data, this);
+  }
+  static runtime = proxy_exports.proto3;
+  static typeName = "libravdb.ipc.v1.RebuildIndexResponse";
+  static fields = proxy_exports.proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: "collections_processed",
+      kind: "scalar",
+      T: 5
+      /* ScalarType.INT32 */
+    },
+    {
+      no: 2,
+      name: "records_reindexed",
+      kind: "scalar",
+      T: 5
+      /* ScalarType.INT32 */
+    },
+    {
+      no: 3,
+      name: "collections_recreated",
+      kind: "scalar",
+      T: 5
+      /* ScalarType.INT32 */
+    },
+    { no: 4, name: "errors", kind: "scalar", T: 9, repeated: true }
+  ]);
+  static fromBinary(bytes, options) {
+    return new _RebuildIndexResponse().fromBinary(bytes, options);
+  }
+  static fromJson(jsonValue, options) {
+    return new _RebuildIndexResponse().fromJson(jsonValue, options);
+  }
+  static fromJsonString(jsonString, options) {
+    return new _RebuildIndexResponse().fromJsonString(jsonString, options);
+  }
+  static equals(a, b) {
+    return proxy_exports.proto3.util.equals(_RebuildIndexResponse, a, b);
+  }
+};
+
+// src/ingest-queue.ts
+var DEFAULT_OPTIONS = {
+  chunkTokens: 8192,
+  retryBaseDelayMs: 500,
+  maxRetries: 4
+};
+var IngestQueue = class {
+  queue = [];
+  rpcCall;
+  logger;
+  options;
+  running = false;
+  constructor(rpcCall, logger, options = {}) {
+    this.rpcCall = rpcCall;
+    this.logger = logger;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async enqueueIngest(sourceDoc, text, baseParams) {
+    if (this.options.chunkTokens === Infinity) {
+      return this.ingestWithRetry({
+        ...baseParams,
+        sourceDoc,
+        text,
+        mode: IngestMode.REPLACE
+      });
+    }
+    const chunks = splitIntoChunks(text, this.options.chunkTokens);
+    if (chunks.length === 1) {
+      return this.ingestWithRetry({
+        ...baseParams,
+        sourceDoc,
+        text: chunks[0].text,
+        mode: IngestMode.REPLACE
+      });
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      const isFirst = i === 0;
+      const chunkParams = {
+        ...baseParams,
+        sourceDoc,
+        text: chunks[i].text,
+        mode: isFirst ? IngestMode.REPLACE : IngestMode.APPEND
+      };
+      await this.ingestWithRetry(chunkParams);
+    }
+  }
+  async ingestWithRetry(params) {
+    await withRetry(
+      () => this.rpcCall("ingest_markdown_document", params),
+      this.options.maxRetries,
+      this.options.retryBaseDelayMs,
+      this.logger,
+      `ingest_markdown_document(${params.sourceDoc})`
+    );
+  }
+  async enqueueDelete(sourceDoc) {
+    await withRetry(
+      () => this.rpcCall("delete_authored_document", { sourceDoc }),
+      this.options.maxRetries,
+      this.options.retryBaseDelayMs,
+      this.logger,
+      `delete_authored_document(${sourceDoc})`
+    );
+  }
+};
+function splitIntoChunks(text, maxTokens) {
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) {
+    return [{ text, ordinal: 0 }];
+  }
+  const chunks = [];
+  let offset = 0;
+  let ordinal = 0;
+  while (offset < text.length) {
+    let end = Math.min(offset + maxChars, text.length);
+    const probeLimit = Math.min(256, end - offset);
+    let hardCut = end;
+    for (let i = 0; i < probeLimit; i++) {
+      const pos = end - i;
+      const ch = text.charAt(pos);
+      if (ch === "\n" && text.charAt(pos + 1) === "\n") {
+        hardCut = pos + 2;
+        break;
+      }
+    }
+    if (hardCut === end) {
+      for (let i = 0; i < probeLimit; i++) {
+        const pos = end - i;
+        if (text.charAt(pos) === "\n") {
+          hardCut = pos + 1;
+          break;
+        }
+      }
+    }
+    if (hardCut === end) {
+      for (let i = 0; i < probeLimit; i++) {
+        const pos = end - i;
+        if (text.charAt(pos) === " ") {
+          hardCut = pos;
+          break;
+        }
+      }
+    }
+    chunks.push({ text: text.slice(offset, hardCut), ordinal });
+    ordinal++;
+    offset = hardCut;
+  }
+  return chunks;
+}
+async function withRetry(fn, maxRetries, baseDelayMs, logger, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries) {
+        const cap = baseDelayMs * Math.pow(2, attempt);
+        const delay = Math.random() * cap;
+        logger.warn?.(`[ingest-queue] ${label} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${Math.round(delay)}ms: ${err}`);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/markdown-ingest.ts
+var DEFAULT_DEBOUNCE_MS2 = 150;
+var DEFAULT_TOKENIZER_ID = "markdown-ingest:v1";
+var MARKDOWN_INGEST_VERSION = 3;
+var HASH_BACKEND = "wasm-fnv1a64";
+function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsApi = createRealFsApi2()) {
+  const adapters = [];
+  const genericRoots = normalizeMarkdownRoots(cfg.markdownIngestionRoots);
+  if (isMarkdownIngestionEnabled(cfg, genericRoots)) {
+    adapters.push(
+      new DirectoryMarkdownSourceAdapter(
+        "generic",
+        {
+          roots: genericRoots,
+          include: cfg.markdownIngestionInclude,
+          exclude: cfg.markdownIngestionExclude,
+          debounceMs: cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS2
+        },
+        getRpc,
+        logger,
+        fsApi
+      )
+    );
+  }
+  const obsidianRoots = normalizeMarkdownRoots(cfg.markdownIngestionObsidianRoots);
+  if (cfg.markdownIngestionObsidianEnabled !== false && obsidianRoots.length > 0) {
+    adapters.push(
+      new DirectoryMarkdownSourceAdapter(
+        "obsidian",
+        {
+          roots: obsidianRoots,
+          include: cfg.markdownIngestionObsidianInclude,
+          exclude: cfg.markdownIngestionObsidianExclude,
+          debounceMs: cfg.markdownIngestionObsidianDebounceMs ?? cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS2
+        },
+        getRpc,
+        logger,
+        fsApi
+      )
+    );
+  }
+  if (adapters.length === 0) {
+    return {
+      async start() {
+      },
+      async refresh() {
+      },
+      async stop() {
+      }
+    };
+  }
+  const adapter = new CompositeMarkdownSourceAdapter(adapters);
+  return {
+    start: () => adapter.start(),
+    refresh: () => adapter.refresh(),
+    stop: () => adapter.stop()
+  };
+}
+var CompositeMarkdownSourceAdapter = class {
+  constructor(adapters) {
+    this.adapters = adapters;
+  }
+  adapters;
+  kind = "composite";
+  async start() {
+    for (const adapter of this.adapters) {
+      await adapter.start();
+    }
+  }
+  async refresh() {
+    for (const adapter of this.adapters) {
+      await adapter.refresh();
+    }
+  }
+  async stop() {
+    for (const adapter of this.adapters) {
+      await adapter.stop();
+    }
+  }
+};
+var DirectoryMarkdownSourceAdapter = class {
+  kind;
+  roots;
+  includePatterns;
+  excludePatterns;
+  debounceMs;
+  fsApi;
+  getRpc;
+  logger;
+  states = /* @__PURE__ */ new Map();
+  fileStates = /* @__PURE__ */ new Map();
+  activeScans = /* @__PURE__ */ new Set();
+  tokenizerId;
+  coreDoc;
+  started = false;
+  ingestQueue = null;
+  stopping = false;
+  constructor(kind, config, getRpc, logger, fsApi) {
+    this.kind = kind;
+    this.roots = config.roots;
+    this.includePatterns = config.include?.length ? config.include : [];
+    this.excludePatterns = config.exclude?.length ? config.exclude : [];
+    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS2;
+    this.fsApi = fsApi;
+    this.getRpc = getRpc;
+    this.logger = logger;
+    this.tokenizerId = DEFAULT_TOKENIZER_ID;
+    this.coreDoc = true;
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    this.stopping = false;
+    await this.refresh();
+  }
+  async refresh() {
+    if (!this.started || this.stopping) {
+      return;
+    }
+    for (const root of this.roots) {
+      await this.scanRoot(root);
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    for (const state of this.states.values()) {
+      if (state.scanState.timer) {
+        clearTimeout(state.scanState.timer);
+        state.scanState.timer = null;
+      }
+      for (const watcher of state.directoryWatchers.values()) {
+        watcher.close();
+      }
+      state.directoryWatchers.clear();
+    }
+    if (this.activeScans.size > 0) {
+      await Promise.allSettled([...this.activeScans]);
+    }
+    this.states.clear();
+    this.fileStates.clear();
+    this.started = false;
+  }
+  getRootState(root) {
+    const resolved = path2.resolve(root);
+    const existing = this.states.get(resolved);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      root: resolved,
+      scanState: {
+        scanning: false,
+        dirty: false,
+        timer: null
+      },
+      knownFiles: /* @__PURE__ */ new Set(),
+      directoryWatchers: /* @__PURE__ */ new Map()
+    };
+    this.states.set(resolved, created);
+    return created;
+  }
+  async scanRoot(root) {
+    if (!this.started || this.stopping) {
+      return;
+    }
+    const rootState = this.getRootState(root);
+    if (rootState.scanState.scanning) {
+      rootState.scanState.dirty = true;
+      return;
+    }
+    rootState.scanState.scanning = true;
+    const scan = (async () => {
+      try {
+        const currentFiles = /* @__PURE__ */ new Set();
+        await this.walkDirectory(rootState, rootState.root, currentFiles);
+        if (!this.stopping) {
+          await this.pruneDeletedFiles(rootState, currentFiles);
+          rootState.knownFiles = currentFiles;
+        }
+      } finally {
+        rootState.scanState.scanning = false;
+        if (rootState.scanState.dirty) {
+          rootState.scanState.dirty = false;
+          if (!this.stopping) {
+            this.scheduleRootScan(rootState);
+          }
+        }
+      }
+    })();
+    this.activeScans.add(scan);
+    try {
+      await scan;
+    } finally {
+      this.activeScans.delete(scan);
+    }
+  }
+  scheduleRootScan(rootState) {
+    if (!this.started || this.stopping) {
+      return;
+    }
+    if (rootState.scanState.scanning) {
+      rootState.scanState.dirty = true;
+      return;
+    }
+    if (rootState.scanState.timer) {
+      return;
+    }
+    rootState.scanState.timer = setTimeout(() => {
+      rootState.scanState.timer = null;
+      void this.scanRoot(rootState.root).catch((error) => {
+        this.logger.warn?.(`[markdown-ingest] root scan failed for ${rootState.root}: ${formatError(error)}`);
+      });
+    }, this.debounceMs);
+  }
+  async walkDirectory(rootState, dir, currentFiles) {
+    await this.ensureDirectoryWatcher(rootState, dir);
+    let entries;
+    try {
+      entries = await this.fsApi.readdir(dir);
+    } catch (error) {
+      const message = formatError(error);
+      if (!message.includes("ENOENT")) {
+        this.logger.warn?.(`[markdown-ingest] readdir failed for ${dir}: ${message}`);
+      }
+      return;
+    }
+    for (const entry of entries) {
+      if (this.stopping) {
+        return;
+      }
+      const child = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkDirectory(rootState, child, currentFiles);
+        continue;
+      }
+      if (!entry.isFile() || !isMarkdownFile(entry.name)) {
+        continue;
+      }
+      if (!this.shouldIncludeFile(rootState.root, child)) {
+        continue;
+      }
+      currentFiles.add(child);
+      try {
+        await this.syncMarkdownFile(rootState, child);
+      } catch (error) {
+        if (!this.stopping) {
+          this.logger.warn?.(`[markdown-ingest] sync failed for ${child}: ${formatError(error)}`);
+        }
+      }
+    }
+  }
+  async ensureDirectoryWatcher(rootState, dir) {
+    if (rootState.directoryWatchers.has(dir)) {
+      return;
+    }
+    try {
+      const watcher = this.fsApi.watch(dir, () => {
+        if (!this.stopping) {
+          this.scheduleRootScan(rootState);
+        }
+      });
+      watcher.on("error", (error) => {
+        this.logger.warn?.(`[markdown-ingest] watch error for ${dir}: ${formatError(error)}`);
+      });
+      rootState.directoryWatchers.set(dir, watcher);
+    } catch (error) {
+      this.logger.warn?.(`[markdown-ingest] watch unavailable for ${dir}: ${formatError(error)}`);
+    }
+  }
+  shouldIncludeFile(root, filePath) {
+    if (isOpenClawMemoryFile(filePath)) {
+      return true;
+    }
+    const relative = toPosixPath(path2.relative(root, filePath));
+    if (this.excludePatterns.length > 0) {
+      for (const pattern of this.excludePatterns) {
+        if (matchesGlob(relative, pattern)) {
+          return false;
+        }
+      }
+    }
+    if (this.includePatterns.length > 0) {
+      for (const pattern of this.includePatterns) {
+        if (matchesGlob(relative, pattern)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  async pruneDeletedFiles(rootState, currentFiles) {
+    const removed = [];
+    for (const previous of rootState.knownFiles) {
+      if (!currentFiles.has(previous)) {
+        removed.push(previous);
+      }
+    }
+    if (removed.length === 0) {
+      return;
+    }
+    for (const filePath of removed) {
+      await this.deleteSourceDocument(filePath);
+      this.fileStates.delete(filePath);
+    }
+  }
+  async syncMarkdownFile(rootState, filePath) {
+    const sourceDoc = filePath;
+    const relativePath = toPosixPath(path2.relative(rootState.root, filePath));
+    const stat = await this.safeStat(filePath);
+    if (!stat) {
+      await this.deleteSourceDocument(sourceDoc);
+      this.fileStates.delete(sourceDoc);
+      return;
+    }
+    const cached = this.fileStates.get(sourceDoc);
+    if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+      return;
+    }
+    const bytes = await this.safeReadFile(filePath);
+    if (!bytes) {
+      await this.deleteSourceDocument(sourceDoc);
+      this.fileStates.delete(sourceDoc);
+      return;
+    }
+    const fileHash = hashBytes(bytes);
+    if (cached && cached.fileHash === fileHash) {
+      this.fileStates.set(sourceDoc, {
+        root: rootState.root,
+        sourceDoc,
+        relativePath,
+        fileHash,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs
+      });
+      return;
+    }
+    const text = textDecoder2.decode(bytes);
+    if (this.kind === "obsidian" && this.includePatterns.length === 0 && !looksLikeObsidianNote(filePath, text)) {
+      await this.deleteSourceDocument(sourceDoc);
+      this.fileStates.delete(sourceDoc);
+      return;
+    }
+    await this.ingestMarkdownDocument(sourceDoc, text, rootState.root, relativePath, fileHash, stat.size, stat.mtimeMs);
+    this.fileStates.set(sourceDoc, {
+      root: rootState.root,
+      sourceDoc,
+      relativePath,
+      fileHash,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs
+    });
+  }
+  async ingestMarkdownDocument(sourceDoc, text, sourceRoot, sourcePath, fileHash, sourceSize, sourceMtimeMs) {
+    const queue = await this.getIngestQueue();
+    await queue.enqueueIngest(
+      sourceDoc,
+      text,
+      {
+        tokenizerId: this.tokenizerId,
+        coreDoc: this.coreDoc,
+        sourceMeta: {
+          sourceRoot,
+          sourcePath,
+          sourceKind: this.kind,
+          fileHash,
+          sourceSize,
+          sourceMtimeMs: Math.trunc(sourceMtimeMs),
+          ingestVersion: MARKDOWN_INGEST_VERSION,
+          hashBackend: HASH_BACKEND
+        }
+      }
+    );
   }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RankCandidatesResponse";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    { no: 1, name: "ranked", kind: "message", T: RankCandidate, repeated: true }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RankCandidatesResponse().fromBinary(bytes, options);
+  async deleteSourceDocument(sourceDoc) {
+    const queue = await this.getIngestQueue();
+    await queue.enqueueDelete(sourceDoc);
   }
-  static fromJson(jsonValue, options) {
-    return new _RankCandidatesResponse().fromJson(jsonValue, options);
+  async getIngestQueue() {
+    if (!this.ingestQueue) {
+      const rpc = await this.getRpc();
+      this.ingestQueue = new IngestQueue(rpc.call.bind(rpc), this.logger);
+    }
+    return this.ingestQueue;
   }
-  static fromJsonString(jsonString, options) {
-    return new _RankCandidatesResponse().fromJsonString(jsonString, options);
+  async safeStat(filePath) {
+    try {
+      return await this.fsApi.stat(filePath);
+    } catch {
+      return null;
+    }
   }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RankCandidatesResponse, a, b);
+  async safeReadFile(filePath) {
+    try {
+      return await this.fsApi.readFile(filePath);
+    } catch {
+      return null;
+    }
   }
 };
-var RebuildIndexRequest = class _RebuildIndexRequest extends proxy_exports.Message {
-  /**
-   * @generated from field: string namespace = 1;
-   */
-  namespace = "";
-  /**
-   * @generated from field: repeated string collections = 2;
-   */
-  collections = [];
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
-  }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RebuildIndexRequest";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "namespace",
-      kind: "scalar",
-      T: 9
-      /* ScalarType.STRING */
-    },
-    { no: 2, name: "collections", kind: "scalar", T: 9, repeated: true }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RebuildIndexRequest().fromBinary(bytes, options);
-  }
-  static fromJson(jsonValue, options) {
-    return new _RebuildIndexRequest().fromJson(jsonValue, options);
-  }
-  static fromJsonString(jsonString, options) {
-    return new _RebuildIndexRequest().fromJsonString(jsonString, options);
+function toPosixPath(value) {
+  return value.split(path2.sep).join("/");
+}
+var textDecoder2 = new TextDecoder();
+function normalizeMarkdownRoots(roots) {
+  if (!roots?.length) {
+    return [];
   }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RebuildIndexRequest, a, b);
+  const resolved = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const trimmed = root.trim();
+    if (!trimmed) {
+      continue;
+    }
+    resolved.add(path2.resolve(trimmed));
   }
-};
-var RebuildIndexResponse = class _RebuildIndexResponse extends proxy_exports.Message {
-  /**
-   * @generated from field: int32 collections_processed = 1;
-   */
-  collectionsProcessed = 0;
-  /**
-   * @generated from field: int32 records_reindexed = 2;
-   */
-  recordsReindexed = 0;
-  /**
-   * @generated from field: int32 collections_recreated = 3;
-   */
-  collectionsRecreated = 0;
-  /**
-   * @generated from field: repeated string errors = 4;
-   */
-  errors = [];
-  constructor(data) {
-    super();
-    proxy_exports.proto3.util.initPartial(data, this);
+  return [...resolved];
+}
+function isMarkdownIngestionEnabled(cfg, roots) {
+  if (cfg.markdownIngestionEnabled === false) {
+    return false;
   }
-  static runtime = proxy_exports.proto3;
-  static typeName = "libravdb.ipc.v1.RebuildIndexResponse";
-  static fields = proxy_exports.proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: "collections_processed",
-      kind: "scalar",
-      T: 5
-      /* ScalarType.INT32 */
-    },
-    {
-      no: 2,
-      name: "records_reindexed",
-      kind: "scalar",
-      T: 5
-      /* ScalarType.INT32 */
-    },
-    {
-      no: 3,
-      name: "collections_recreated",
-      kind: "scalar",
-      T: 5
-      /* ScalarType.INT32 */
+  return roots.length > 0;
+}
+function createRealFsApi2() {
+  return {
+    readdir: async (dir) => fsp2.readdir(dir, { withFileTypes: true }),
+    readFile: async (file) => fsp2.readFile(file),
+    stat: async (file) => {
+      const stat = await fsp2.stat(file);
+      return { size: stat.size, mtimeMs: stat.mtimeMs };
     },
-    { no: 4, name: "errors", kind: "scalar", T: 9, repeated: true }
-  ]);
-  static fromBinary(bytes, options) {
-    return new _RebuildIndexResponse().fromBinary(bytes, options);
+    watch: (dir, onChange) => fs2.watch(dir, onChange)
+  };
+}
+function isMarkdownFile(fileName) {
+  const lower = fileName.toLowerCase();
+  return lower.endsWith(".md") || lower.endsWith(".markdown");
+}
+function matchesGlob(value, pattern) {
+  const escaped = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+function looksLikeObsidianNote(filePath, text) {
+  if (!text.startsWith("---\n")) {
+    return hasInlineObsidianTag(text);
   }
-  static fromJson(jsonValue, options) {
-    return new _RebuildIndexResponse().fromJson(jsonValue, options);
+  const frontmatterEnd = findFrontmatterEnd(text, 4);
+  if (frontmatterEnd < 0) {
+    return hasInlineObsidianTag(text);
   }
-  static fromJsonString(jsonString, options) {
-    return new _RebuildIndexResponse().fromJsonString(jsonString, options);
+  const frontmatter = text.slice(4, frontmatterEnd);
+  const lines = frontmatter.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("tags:") || trimmed.startsWith("tag:") || trimmed.startsWith("openclaw:") || trimmed.startsWith("memory:")) {
+      return true;
+    }
   }
-  static equals(a, b) {
-    return proxy_exports.proto3.util.equals(_RebuildIndexResponse, a, b);
+  return hasInlineObsidianTag(text.slice(frontmatterEnd + 4));
+}
+function findFrontmatterEnd(text, offset) {
+  for (let i = offset; i < text.length - 3; i++) {
+    if (text.charCodeAt(i) !== 45 || text.charCodeAt(i + 1) !== 45 || text.charCodeAt(i + 2) !== 45) {
+      continue;
+    }
+    const next = text.charCodeAt(i + 3);
+    if (next === 10) {
+      return i;
+    }
+    if (next === 13 && text.charCodeAt(i + 4) === 10) {
+      return i;
+    }
   }
-};
+  return -1;
+}
+function hasInlineObsidianTag(text) {
+  let inFence = false;
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      continue;
+    }
+    if (/(^|[^A-Za-z0-9_])#([A-Za-z][A-Za-z0-9/_-]*)\b/.test(line)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isOpenClawMemoryFile(filePath) {
+  return path2.basename(filePath).toLowerCase() === "memory.md";
+}
+
+// src/memory-provider.ts
+var MEMORY_PROMPT_HEADER = [
+  "## Memory",
+  "LibraVDB persistent memory is configured. Recalled memories may appear",
+  "in context via the context-engine assembler when available and relevant.",
+  ""
+];
+function buildMemoryPromptSection(_getRpc, _cfg) {
+  return function memoryPromptSection({
+    availableTools: _availableTools,
+    citationsMode: _citationsMode
+  }) {
+    return [...MEMORY_PROMPT_HEADER];
+  };
+}
 
 // src/rpc-protobuf-codecs.ts
 function encodeMessage(schema, init) {
@@ -39308,7 +39464,7 @@ var SidecarSupervisor = class {
         this.logger.info?.(
           `[libravdb] Daemon not ready, retrying connection (attempt ${attempt + 1}/${STARTUP_CONNECT_MAX_RETRIES})...`
         );
-        await sleep(delayMs);
+        await sleep2(delayMs);
       }
     }
   }
@@ -39490,7 +39646,7 @@ function isConfiguredEndpoint(value) {
   const port = Number(address.slice(separator + 1));
   return host.length > 0 && Number.isInteger(port) && port > 0 && port <= 65535;
 }
-function sleep(delayMs) {
+function sleep2(delayMs) {
   return new Promise((resolve) => setTimeout(resolve, delayMs));
 }