@dikolab/kbdb 0.3.2 → 0.4.1

package/dist/kbdb-worker.cjs

@@ -2,7 +2,7 @@
 "use strict";
 
 // src/worker.ts
-var import_node_fs6 = require("node:fs");
+var import_node_fs10 = require("node:fs");
 
 // src/shared/runtime/functions/detect-runtime.ts
 function detectRuntime() {
@@ -66,62 +66,139 @@ var DEFAULT_ITEM_TTL_MS = 6e4;
 var WORKER_TOML_FILENAME = "worker.toml";
 var DB_FORMAT_VERSION = 1;
 
-// src/shared/worker-daemon/functions/read-config.function.ts
-function readConfig(contextPath) {
-  const configPath = (0, import_node_path3.join)(contextPath, WORKER_TOML_FILENAME);
-  try {
-    const text = (0, import_node_fs.readFileSync)(configPath, "utf-8");
-    return parseWorkerToml(text, contextPath);
-  } catch {
-    return {
-      contextPath,
-      itemLimit: DEFAULT_ITEM_LIMIT,
-      indexLimit: DEFAULT_INDEX_LIMIT,
-      timeoutMs: DEFAULT_TIMEOUT_MS,
-      itemTtlMs: DEFAULT_ITEM_TTL_MS
-    };
+// src/shared/worker-daemon/functions/parse-embedding-section.function.ts
+function parseEmbeddingSection(entries) {
+  const provider = entries.get("provider");
+  if (!provider) {
+    return void 0;
+  }
+  const model = entries.get("model");
+  const endpoint = entries.get("endpoint");
+  const dimensionsRaw = entries.get("dimensions");
+  const dimensions = dimensionsRaw ? parseInt(dimensionsRaw, 10) || void 0 : void 0;
+  return {
+    provider,
+    ...model !== void 0 ? { model } : {},
+    ...endpoint !== void 0 ? { endpoint } : {},
+    ...dimensions !== void 0 ? { dimensions } : {}
+  };
+}
+
+// src/shared/auto-capture/constants/auto-capture-defaults.constant.ts
+var AUTO_CAPTURE_DEFAULTS = {
+  enabled: false,
+  triggerAfterToolCalls: 5,
+  minIntervalMs: 6e4,
+  maxCapturesPerSession: 10,
+  dryRun: false
+};
+
+// src/shared/worker-daemon/functions/parse-auto-capture-section.function.ts
+function parseAutoCaptureSection(entries) {
+  const enabled = entries.has("enabled") ? entries.get("enabled") === "true" : AUTO_CAPTURE_DEFAULTS.enabled;
+  const dryRun = entries.has("dry_run") ? entries.get("dry_run") === "true" : AUTO_CAPTURE_DEFAULTS.dryRun;
+  const triggerRaw = entries.get("trigger_after_tool_calls");
+  const triggerAfterToolCalls = triggerRaw ? parseInt(triggerRaw, 10) || AUTO_CAPTURE_DEFAULTS.triggerAfterToolCalls : AUTO_CAPTURE_DEFAULTS.triggerAfterToolCalls;
+  const intervalRaw = entries.get("min_interval_ms");
+  const minIntervalMs = intervalRaw ? parseInt(intervalRaw, 10) || AUTO_CAPTURE_DEFAULTS.minIntervalMs : AUTO_CAPTURE_DEFAULTS.minIntervalMs;
+  const capRaw = entries.get("max_captures_per_session");
+  const maxCapturesPerSession = capRaw ? parseInt(capRaw, 10) || AUTO_CAPTURE_DEFAULTS.maxCapturesPerSession : AUTO_CAPTURE_DEFAULTS.maxCapturesPerSession;
+  return {
+    enabled,
+    triggerAfterToolCalls,
+    minIntervalMs,
+    maxCapturesPerSession,
+    dryRun
+  };
+}
+
+// src/shared/worker-daemon/functions/parse-worker-toml.function.ts
+function applyRootKey(acc, key, value) {
+  switch (key) {
+    case "item_limit":
+      acc.itemLimit = parseInt(value, 10) || DEFAULT_ITEM_LIMIT;
+      break;
+    case "index_limit":
+      acc.indexLimit = parseInt(value, 10) || DEFAULT_INDEX_LIMIT;
+      break;
+    case "timeout_ms":
+      acc.timeoutMs = parseInt(value, 10) || DEFAULT_TIMEOUT_MS;
+      break;
+    case "item_ttl_ms":
+      acc.itemTtlMs = parseInt(value, 10) || DEFAULT_ITEM_TTL_MS;
+      break;
+    default:
+      break;
   }
 }
 function parseWorkerToml(text, contextPath) {
-  const config = {
-    contextPath,
+  let section = "";
+  const embeddingEntries = /* @__PURE__ */ new Map();
+  const autoCaptureEntries = /* @__PURE__ */ new Map();
+  const acc = {
     itemLimit: DEFAULT_ITEM_LIMIT,
     indexLimit: DEFAULT_INDEX_LIMIT,
     timeoutMs: DEFAULT_TIMEOUT_MS,
     itemTtlMs: DEFAULT_ITEM_TTL_MS
   };
-  const result = { ...config };
   for (const line of text.split("\n")) {
     const trimmed = line.trim();
-    if (trimmed.startsWith("#") || !trimmed.includes("=")) {
+    if (trimmed === "[embedding]") {
+      section = "embedding";
+      continue;
+    }
+    if (trimmed === "[auto_capture]") {
+      section = "auto_capture";
+      continue;
+    }
+    if (trimmed.startsWith("[")) {
+      section = "";
       continue;
     }
+    if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
     const eqIdx = trimmed.indexOf("=");
     const key = trimmed.slice(0, eqIdx).trim();
     const value = trimmed.slice(eqIdx + 1).trim();
-    switch (key) {
-      case "item_limit":
-        result.itemLimit = parseInt(value, 10) || DEFAULT_ITEM_LIMIT;
-        break;
-      case "index_limit":
-        result.indexLimit = parseInt(value, 10) || DEFAULT_INDEX_LIMIT;
-        break;
-      case "timeout_ms":
-        result.timeoutMs = parseInt(value, 10) || DEFAULT_TIMEOUT_MS;
-        break;
-      case "item_ttl_ms":
-        result.itemTtlMs = parseInt(value, 10) || DEFAULT_ITEM_TTL_MS;
-        break;
-      default:
-        break;
+    if (section === "embedding") {
+      embeddingEntries.set(key, value);
+      continue;
+    }
+    if (section === "auto_capture") {
+      autoCaptureEntries.set(key, value);
+      continue;
     }
+    applyRootKey(acc, key, value);
+  }
+  const embedding = parseEmbeddingSection(embeddingEntries);
+  const autoCapture = autoCaptureEntries.size > 0 ? parseAutoCaptureSection(autoCaptureEntries) : void 0;
+  return {
+    contextPath,
+    ...acc,
+    ...embedding !== void 0 ? { embedding } : {},
+    ...autoCapture !== void 0 ? { autoCapture } : {}
+  };
+}
+
+// src/shared/worker-daemon/functions/read-config.function.ts
+function readConfig(contextPath) {
+  const configPath = (0, import_node_path3.join)(contextPath, WORKER_TOML_FILENAME);
+  try {
+    const text = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    return parseWorkerToml(text, contextPath);
+  } catch {
+    return {
+      contextPath,
+      itemLimit: DEFAULT_ITEM_LIMIT,
+      indexLimit: DEFAULT_INDEX_LIMIT,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+      itemTtlMs: DEFAULT_ITEM_TTL_MS
+    };
   }
-  return result;
 }
 
 // src/shared/worker-daemon/functions/start-daemon.function.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
 var import_node_os3 = require("node:os");
 
 // src/shared/hash/functions/compute-sha256.ts
@@ -133,10 +210,77 @@ async function computeSha256(input) {
 }
 
 // src/shared/worker-daemon/classes/worker-daemon.class.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path9 = require("node:path");
 var import_node_os2 = require("node:os");
 
+// src/shared/log/typings/log-level.type.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARNING"] = 2] = "WARNING";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/shared/log/constants/log-colors.constant.ts
+var ANSI_RESET = "\x1B[0m";
+var LOG_COLORS = {
+  [0 /* DEBUG */]: "\x1B[37m",
+  [1 /* INFO */]: "\x1B[36m",
+  [2 /* WARNING */]: "\x1B[33m",
+  [3 /* ERROR */]: "\x1B[91m"
+};
+
+// src/shared/log/constants/log-icons.constant.ts
+var LOG_ICONS = {
+  [0 /* DEBUG */]: "\u25B8",
+  [1 /* INFO */]: "\u2139",
+  [2 /* WARNING */]: "\u26A0",
+  [3 /* ERROR */]: "\u2716"
+};
+
+// src/shared/log/constants/log-defaults.constant.ts
+var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
+
+// src/shared/log/functions/write-stderr.function.ts
+function writeStderr(message) {
+  const g = globalThis;
+  const proc = g["process"];
+  if (proc?.stderr) {
+    proc.stderr.write(message);
+    return;
+  }
+  const deno = g["Deno"];
+  deno?.stderr.writeSync(new TextEncoder().encode(message));
+}
+
+// src/shared/log/functions/log.function.ts
+var currentLevel = DEFAULT_LOG_LEVEL;
+var outputs = {
+  [0 /* DEBUG */]: writeStderr,
+  [1 /* INFO */]: writeStderr,
+  [2 /* WARNING */]: writeStderr,
+  [3 /* ERROR */]: writeStderr
+};
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setLogOutput(level, output) {
+  outputs[level] = output;
+}
+function log(message, level = 3 /* ERROR */) {
+  if (level < currentLevel) {
+    return;
+  }
+  const color = LOG_COLORS[level];
+  const icon = LOG_ICONS[level];
+  const name = LogLevel[level];
+  const line = `${color}${icon} [${name}] ${message}${ANSI_RESET}
+`;
+  outputs[level](line);
+}
+
 // src/shared/worker-daemon/functions/load-wasm-modules.function.ts
 var import_node_fs3 = require("node:fs");
 
@@ -165,6 +309,7 @@ var nullAllocator = { alloc: null };
 function createHostImports(contextPath, memoryRef = nullMemory, fs = nodeFsAdapter, allocator = nullAllocator) {
   function getBuffer() {
     if (!memoryRef.memory) {
+      log("WASM memory not initialized", 3 /* ERROR */);
       throw new Error("WASM memory not initialized");
     }
     return memoryRef.memory.buffer;
@@ -333,6 +478,7 @@ async function loadWasmModules(config, wasmDir2) {
     void 0,
     allocator
   );
+  log("loading WASM module: kb-worker", 0 /* DEBUG */);
   const wkPath = joinPath(wasmDir2, "kb-worker", "kbdb_worker_bg.wasm");
   const wkBytes = await readWasmFile(wkPath, "kb-worker");
   let wkModule;
@@ -356,7 +502,20 @@ async function loadWasmModules(config, wasmDir2) {
     if (typeof fn_ !== "function") return 0;
     return fn_(size);
   };
-  return { memory, kbWorker };
+  const embPath = joinPath(
+    wasmDir2,
+    "default-embedding",
+    "kbdb_default_embedding_bg.wasm"
+  );
+  let embedding;
+  try {
+    const embBytes = await readWasmFile(embPath, "default-embedding");
+    const embModule = await WebAssembly.compile(embBytes);
+    embedding = await WebAssembly.instantiate(embModule, {});
+  } catch {
+  }
+  log("all WASM modules loaded", 1 /* INFO */);
+  return { memory, kbWorker, embedding };
 }
 async function readWasmFile(path, label) {
   try {
@@ -382,17 +541,25 @@ function rethrow(stage, label, err, path) {
   const detail = err instanceof Error ? err.message : String(err);
   const suffix = path ? ` (path: ${path})` : "";
   const message = `failed to ${stage} ${label} WASM: ${detail}${suffix}`;
-  console.error(`kbdb-worker: ${message}`);
+  log(`kbdb-worker: ${message}`, 3 /* ERROR */);
   throw new Error(message, { cause: err });
 }
 
 // src/shared/worker-daemon/functions/create-ipc-server.function.ts
 var import_node_net = require("node:net");
+var LISTEN_BACKLOG = 256;
+var KEEPALIVE_MS = 3e4;
 function createIpcServer(socketPath, handler) {
   const server = (0, import_node_net.createServer)((socket) => {
+    socket.setKeepAlive(true, KEEPALIVE_MS);
+    log("ipc: connection accepted", 0 /* DEBUG */);
     let buffer = "";
     let processingQueue = Promise.resolve();
     socket.on("data", (chunk) => {
+      log(
+        "ipc: data received bytes=" + String(chunk.length),
+        0 /* DEBUG */
+      );
       buffer += chunk.toString();
       const lines = buffer.split("\n");
       buffer = lines.pop() ?? "";
@@ -404,16 +571,28 @@ function createIpcServer(socketPath, handler) {
       }
     });
     socket.on("error", (err) => {
-      console.error(
-        `kbdb-worker: ipc connection error: ${err.message}`
+      log(
+        `kbdb-worker: ipc connection error: ${err.message}`,
+        2 /* WARNING */
       );
     });
   });
-  server.on("error", (err) => {
-    console.error(`kbdb-worker: ipc server error: ${err.message}`);
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(
+      { path: socketPath, backlog: LISTEN_BACKLOG },
+      () => {
+        server.removeListener("error", reject);
+        server.on("error", (err) => {
+          log(
+            `kbdb-worker: ipc server error: ${err.message}`,
+            3 /* ERROR */
+          );
+        });
+        resolve2(server);
+      }
+    );
   });
-  server.listen(socketPath);
-  return server;
 }
 function bigintReplacer(_key, value) {
   return typeof value === "bigint" ? Number(value) : value;
@@ -422,8 +601,13 @@ async function handleLine(line, handler, socket) {
   let response;
   try {
     const request = JSON.parse(line);
+    log(
+      "ipc: request parsed method=" + request.method + " id=" + String(request.id),
+      0 /* DEBUG */
+    );
     response = await handler(request);
   } catch {
+    log("ipc: parse error on malformed request", 0 /* DEBUG */);
     response = {
       jsonrpc: "2.0",
       id: 0,
@@ -433,7 +617,12 @@ async function handleLine(line, handler, socket) {
       }
     };
   }
-  socket.write(JSON.stringify(response, bigintReplacer) + "\n");
+  const encoded = JSON.stringify(response, bigintReplacer) + "\n";
+  log(
+    "ipc: response sent bytes=" + String(encoded.length),
+    0 /* DEBUG */
+  );
+  socket.write(encoded);
 }
 
 // src/shared/platform/functions/get-ipc-path.function.ts
@@ -453,6 +642,535 @@ function getIpcPath(ctx) {
   return (0, import_node_path5.join)(getTmpdir(), `kbdb-${ctx}.sock`);
 }
 
+// src/shared/embedding/classes/null-embedding-provider.class.ts
+var NullEmbeddingProvider = class {
+  /**
+   * Returns an empty `Float32Array` for each input text.
+   *
+   * @param texts - input strings (contents are ignored)
+   */
+  embed(texts) {
+    return Promise.resolve(texts.map(() => new Float32Array(0)));
+  }
+  /** Always returns 0 -- no dimensions when disabled. */
+  dimensions() {
+    return 0;
+  }
+  /** Always returns `'none'`. */
+  modelName() {
+    return "none";
+  }
+};
+
+// src/shared/embedding/classes/onnx-embedding-provider.class.ts
+var OnnxEmbeddingProvider = class {
+  /** Path to the ONNX model file. */
+  model;
+  /** Number of embedding dimensions the model produces. */
+  dims;
+  /**
+   * @param model - filesystem path to the ONNX model file
+   * @param dimensions - number of dimensions the model produces
+   */
+  constructor(model, dimensions) {
+    this.model = model;
+    this.dims = dimensions;
+  }
+  /**
+   * Not yet implemented.
+   *
+   * @throws {Error} always -- ONNX Runtime is an optional peer
+   *   dependency not yet wired
+   */
+  embed(_texts) {
+    log("embed called on OnnxEmbeddingProvider", 0 /* DEBUG */);
+    return Promise.reject(
+      new Error(
+        "ONNX Runtime not available; install onnxruntime-node"
+      )
+    );
+  }
+  /** Returns the configured number of embedding dimensions. */
+  dimensions() {
+    return this.dims;
+  }
+  /** Returns the configured model file path. */
+  modelName() {
+    return this.model;
+  }
+};
+
+// src/shared/embedding/functions/parse-api-embedding-response.function.ts
+function parseApiEmbeddingResponse(raw) {
+  if (!isEmbeddingApiResponse(raw)) {
+    log("Unexpected embedding API response shape", 3 /* ERROR */);
+    throw new Error("Unexpected embedding API response shape");
+  }
+  return raw.data.map((entry) => new Float32Array(entry.embedding));
+}
+function isEmbeddingApiResponse(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (!Array.isArray(candidate["data"])) {
+    return false;
+  }
+  return candidate["data"].every(isEmbeddingEntry);
+}
+function isEmbeddingEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return Array.isArray(candidate["embedding"]);
+}
+
+// src/shared/embedding/classes/api-embedding-provider.class.ts
+var ApiEmbeddingProvider = class {
+  /** Remote endpoint URL for embedding requests. */
+  endpoint;
+  /** Number of dimensions in the returned vectors. */
+  dims;
+  /** Model name sent in the request body. */
+  model;
+  /**
+   * @param endpoint - URL to POST embedding requests to
+   * @param dimensions - number of vector dimensions expected
+   * @param model - optional model name; defaults to `'api'`
+   */
+  constructor(endpoint, dimensions, model) {
+    this.endpoint = endpoint;
+    this.dims = dimensions;
+    this.model = model ?? "api";
+  }
+  /**
+   * Posts texts to the endpoint and returns one `Float32Array`
+   * per input.
+   *
+   * @throws {Error} when the HTTP response status is not 2xx
+   */
+  async embed(texts) {
+    const response = await fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ input: texts, model: this.model })
+    });
+    if (!response.ok) {
+      const msg = `Embedding API error: ${String(response.status)}`;
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
+    }
+    const json = await response.json();
+    return parseApiEmbeddingResponse(json);
+  }
+  /** Returns the configured number of embedding dimensions. */
+  dimensions() {
+    return this.dims;
+  }
+  /** Returns the configured model name, defaulting to `'api'`. */
+  modelName() {
+    return this.model;
+  }
+};
+
+// src/shared/embedding/constants/tfidf-defaults.constant.ts
+var TFIDF_DIMENSIONS = 256;
+var TFIDF_MODEL_NAME = "tfidf-v1";
+
+// src/shared/embedding/classes/tfidf-embedding-provider.class.ts
+var TfidfEmbeddingProvider = class {
+  _alloc;
+  _batch;
+  _retPtr;
+  _memory;
+  /** @param wasm - instantiated `kbdb-default-embedding` WASM module */
+  constructor(wasm) {
+    const ex = wasm.exports;
+    this._memory = ex["memory"];
+    this._alloc = ex["kbdb_alloc"];
+    this._batch = ex["embedding_tfidf_batch"];
+    this._retPtr = ex["get_return_ptr"];
+  }
+  /**
+   * Embeds a batch of texts using TF-IDF computation in WASM.
+   *
+   * @param texts - input strings to embed
+   * @returns one 256-dimension `Float32Array` per input text
+   */
+  embed(texts) {
+    log(
+      "embed called on TfidfEmbeddingProvider: " + texts.length.toString() + " texts",
+      0 /* DEBUG */
+    );
+    const input = texts.join("\n");
+    const encoded = new TextEncoder().encode(input);
+    const ptr = this._alloc(encoded.byteLength);
+    const view = new Uint8Array(this._memory.buffer);
+    view.set(encoded, ptr);
+    this._batch(ptr, encoded.byteLength);
+    const outPtr = this._retPtr();
+    const dv = new DataView(this._memory.buffer);
+    const count = dv.getUint32(outPtr, true);
+    const results = [];
+    let offset = outPtr + 4;
+    for (let i = 0; i < count; i++) {
+      const vec = new Float32Array(TFIDF_DIMENSIONS);
+      for (let d = 0; d < TFIDF_DIMENSIONS; d++) {
+        vec[d] = dv.getFloat32(offset, true);
+        offset += 4;
+      }
+      results.push(vec);
+    }
+    return Promise.resolve(results);
+  }
+  /** Returns 256 -- the fixed dimension count for TF-IDF vectors. */
+  dimensions() {
+    return TFIDF_DIMENSIONS;
+  }
+  /** Returns `'tfidf-v1'`. */
+  modelName() {
+    return TFIDF_MODEL_NAME;
+  }
+};
+
+// src/shared/embedding/functions/create-embedding-provider.function.ts
+function createEmbeddingProvider(config, wasmInstance) {
+  log("creating embedding provider", 0 /* DEBUG */);
+  if (!config) {
+    if (wasmInstance) {
+      log("using TfidfEmbeddingProvider", 0 /* DEBUG */);
+      return new TfidfEmbeddingProvider(wasmInstance);
+    }
+    log("using NullEmbeddingProvider", 0 /* DEBUG */);
+    return new NullEmbeddingProvider();
+  }
+  if (config.provider === "none") {
+    log("using NullEmbeddingProvider", 0 /* DEBUG */);
+    return new NullEmbeddingProvider();
+  }
+  if (config.provider === "onnx") {
+    log("using OnnxEmbeddingProvider", 0 /* DEBUG */);
+    return new OnnxEmbeddingProvider(
+      config.model ?? "",
+      config.dimensions ?? 0
+    );
+  }
+  log("using ApiEmbeddingProvider", 0 /* DEBUG */);
+  return new ApiEmbeddingProvider(
+    config.endpoint ?? "",
+    config.dimensions ?? 0,
+    config.model
+  );
+}
+
+// src/shared/worker-daemon/functions/handle-hybrid-search.function.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// src/shared/embedding/functions/search-vectors.function.ts
+var import_node_fs4 = require("node:fs");
+
+// src/shared/embedding/functions/cosine-similarity.function.ts
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    dot += ai * bi;
+    magA += ai * ai;
+    magB += bi * bi;
+  }
+  if (magA === 0 || magB === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+
+// src/shared/embedding/functions/search-vectors.function.ts
+var HEADER_SIZE = 32;
+var KBID_WIDTH = 64;
+function searchVectors(filePath, queryVector, topN) {
+  log("searching vectors", 0 /* DEBUG */);
+  const buf = (0, import_node_fs4.readFileSync)(filePath);
+  if (buf.length < HEADER_SIZE) {
+    return [];
+  }
+  const dimensions = buf.readUInt32LE(8);
+  const count = buf.readUInt32LE(12);
+  const modelLen = buf.readUInt32LE(16);
+  const dataStart = HEADER_SIZE + modelLen;
+  const recordSize = KBID_WIDTH + dimensions * 4;
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    const recOffset = dataStart + i * recordSize;
+    const kbid = buf.toString("utf-8", recOffset, recOffset + KBID_WIDTH).replace(/\0/g, "");
+    const vector = new Float32Array(dimensions);
+    for (let d = 0; d < dimensions; d++) {
+      vector[d] = buf.readFloatLE(recOffset + KBID_WIDTH + d * 4);
+    }
+    const score = cosineSimilarity(queryVector, vector);
+    results.push({ kbid, score });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topN);
+}
+
+// src/shared/embedding/functions/rrf-fuse.function.ts
+var DEFAULT_K = 60;
+function rrfFuse(lexicalRanks, vectorRanks, k = DEFAULT_K) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const [kbid, rank] of lexicalRanks) {
+    scores.set(kbid, (scores.get(kbid) ?? 0) + 1 / (k + rank));
+  }
+  for (const [kbid, rank] of vectorRanks) {
+    scores.set(kbid, (scores.get(kbid) ?? 0) + 1 / (k + rank));
+  }
+  return scores;
+}
+
+// src/shared/worker-daemon/classes/ipc-error.class.ts
+var IpcError = class extends Error {
+  /** JSON-RPC error code. */
+  code;
+  /**
+   * @param code - JSON-RPC error code (e.g. `-32601` for
+   *   method-not-found, `-32000` for application errors)
+   * @param message - human-readable error description
+   */
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "IpcError";
+  }
+};
+
+// src/shared/worker-daemon/functions/handle-hybrid-search.function.ts
+async function fuseSearchResults(lexical, algo, query, provider, targetDir) {
+  log("handling hybrid search", 0 /* DEBUG */);
+  if (algo === "lexical") {
+    return {
+      ...lexical,
+      search_mode: "lexical",
+      retrieval_method: "lexical"
+    };
+  }
+  assertProvider(provider);
+  const embeddings = await provider.embed([query]);
+  if (embeddings.length === 0 || embeddings[0].length === 0) {
+    return {
+      ...lexical,
+      search_mode: algo,
+      retrieval_method: "lexical"
+    };
+  }
+  const queryVec = embeddings[0];
+  const vectorPath = (0, import_node_path6.join)(targetDir, "vectors.idx");
+  const vectorResults = (0, import_node_fs5.existsSync)(vectorPath) ? searchVectors(vectorPath, queryVec, lexical.limit) : [];
+  if (algo === "vector") {
+    return buildVectorOnly(vectorResults, lexical);
+  }
+  return buildHybrid(lexical, vectorResults);
+}
+function assertProvider(provider) {
+  if (!provider || provider.dimensions() === 0) {
+    const embeddingErrMsg = "embedding provider not configured; set [embedding] in worker.toml";
+    log(embeddingErrMsg, 3 /* ERROR */);
+    throw new IpcError(-32e3, embeddingErrMsg);
+  }
+}
+function buildVectorOnly(vectorResults, lexical) {
+  const lookup = new Map(
+    lexical.items.map((item) => [item.kbid, item])
+  );
+  const items = vectorResults.map((vr) => {
+    const existing = lookup.get(vr.kbid);
+    if (existing) {
+      return { ...existing, score: vr.score };
+    }
+    return emptyItem(vr.kbid, vr.score);
+  });
+  return {
+    items,
+    total: items.length,
+    offset: lexical.offset,
+    limit: lexical.limit,
+    has_more: false,
+    relaxed: lexical.relaxed,
+    search_mode: "vector",
+    retrieval_method: "vector"
+  };
+}
+function buildHybrid(lexical, vectorResults) {
+  const lexRanks = /* @__PURE__ */ new Map();
+  lexical.items.forEach((item, i) => {
+    lexRanks.set(item.kbid, i + 1);
+  });
+  const vecRanks = /* @__PURE__ */ new Map();
+  vectorResults.forEach((vr, i) => {
+    vecRanks.set(vr.kbid, i + 1);
+  });
+  const fused = rrfFuse(lexRanks, vecRanks);
+  const sorted = [...fused.entries()].sort((a, b) => b[1] - a[1]);
+  const lookup = new Map(
+    lexical.items.map((item) => [item.kbid, item])
+  );
+  const items = sorted.slice(0, lexical.limit).map(([kbid, score]) => {
+    const existing = lookup.get(kbid);
+    if (existing) {
+      return { ...existing, score };
+    }
+    return emptyItem(kbid, score);
+  });
+  return {
+    items,
+    total: sorted.length,
+    offset: lexical.offset,
+    limit: lexical.limit,
+    has_more: sorted.length > lexical.limit,
+    relaxed: lexical.relaxed,
+    search_mode: "hybrid",
+    retrieval_method: "rrf"
+  };
+}
+function emptyItem(kbid, score) {
+  return {
+    kbid,
+    heading: null,
+    type: "",
+    docids: [],
+    score,
+    confidence: 0,
+    snippet: "",
+    matched_terms: [],
+    matched_fields: [],
+    created_at: ""
+  };
+}
+
+// src/shared/embedding/functions/rebuild-vectors.function.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path8 = require("node:path");
+
+// src/shared/embedding/functions/build-vector-index.function.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path7 = require("node:path");
+var MAGIC = "KBVX";
+var VERSION = 1;
+var KBID_WIDTH2 = 64;
+var HEADER_SIZE2 = 32;
+function writeHeader(buf, dimensions, count, modelLen) {
+  buf.write(MAGIC, 0, "ascii");
+  buf.writeUInt32LE(VERSION, 4);
+  buf.writeUInt32LE(dimensions, 8);
+  buf.writeUInt32LE(count, 12);
+  buf.writeUInt32LE(modelLen, 16);
+}
+function writeRecord(buf, offset, entry, dimensions, encoder3) {
+  const kbidBytes = encoder3.encode(entry.kbid);
+  kbidBytes.forEach((b, i) => {
+    if (i < KBID_WIDTH2) buf.writeUInt8(b, offset + i);
+  });
+  for (let d = 0; d < dimensions; d++) {
+    buf.writeFloatLE(
+      entry.vector[d] ?? 0,
+      offset + KBID_WIDTH2 + d * 4
+    );
+  }
+}
+function buildVectorIndex(dirPath, modelName, dimensions, entries) {
+  log("building vector index", 0 /* DEBUG */);
+  const encoder3 = new TextEncoder();
+  const modelBytes = encoder3.encode(modelName);
+  const modelLen = modelBytes.length;
+  const recordSize = KBID_WIDTH2 + dimensions * 4;
+  const totalSize = HEADER_SIZE2 + modelLen + entries.length * recordSize;
+  const buf = Buffer.alloc(totalSize, 0);
+  writeHeader(buf, dimensions, entries.length, modelLen);
+  modelBytes.forEach((b, i) => buf.writeUInt8(b, HEADER_SIZE2 + i));
+  let recOffset = HEADER_SIZE2 + modelLen;
+  for (const entry of entries) {
+    writeRecord(buf, recOffset, entry, dimensions, encoder3);
+    recOffset += recordSize;
+  }
+  (0, import_node_fs6.writeFileSync)((0, import_node_path7.join)(dirPath, "vectors.idx"), buf);
+  return Promise.resolve();
+}
+
+// src/shared/embedding/functions/rebuild-vectors.function.ts
+var SECTION_SEPARATOR = "\n---\n";
+function extractBody(raw) {
+  const sep = raw.indexOf(SECTION_SEPARATOR);
+  return sep >= 0 ? raw.slice(sep + SECTION_SEPARATOR.length) : raw;
+}
+function collectSections(sectionsDir) {
+  let shards;
+  try {
+    shards = (0, import_node_fs7.readdirSync)(sectionsDir);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const shard of shards) {
+    let files;
+    try {
+      files = (0, import_node_fs7.readdirSync)((0, import_node_path8.join)(sectionsDir, shard));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".section")) continue;
+      const kbid = file.slice(0, -8);
+      try {
+        const raw = (0, import_node_fs7.readFileSync)(
+          (0, import_node_path8.join)(sectionsDir, shard, file),
+          "utf-8"
+        );
+        const body = extractBody(raw);
+        if (body.length > 0) {
+          result.push({ kbid, body });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return result;
+}
+async function rebuildVectors(targetDir, provider) {
+  log("rebuilding vectors", 0 /* DEBUG */);
+  if (provider.dimensions() === 0) {
+    return 0;
+  }
+  const sectionsDir = (0, import_node_path8.join)(targetDir, "sections");
+  if (!(0, import_node_fs7.existsSync)(sectionsDir)) {
+    return 0;
+  }
+  const sections = collectSections(sectionsDir);
+  if (sections.length === 0) {
+    return 0;
+  }
+  const texts = sections.map((s) => s.body);
+  const vectors = await provider.embed(texts);
+  const entries = sections.map((s, i) => ({
+    kbid: s.kbid,
+    vector: vectors[i] ?? new Float32Array(provider.dimensions())
+  }));
+  await buildVectorIndex(
+    targetDir,
+    provider.modelName(),
+    provider.dimensions(),
+    entries
+  );
+  log(
+    "rebuilt " + sections.length.toString() + " vectors",
+    1 /* INFO */
+  );
+  return sections.length;
+}
+
 // src/shared/wasm-codec/functions/encode-string.function.ts
 var encoder = new TextEncoder();
 function encodeString(value) {
@@ -1270,7 +1988,9 @@ var WASM_METHOD_MAP = {
   list_docs_by_type: "worker_list_docs_by_type",
   recall: "worker_recall",
   export: "worker_export",
-  exportDb: "worker_export"
+  exportDb: "worker_export",
+  importDb: "worker_import",
+  import_db: "worker_import"
 };
 var CONFIG_PREFIX = "config_";
 var CONFIG_KEY_MAP = {
@@ -1279,7 +1999,7 @@ var CONFIG_KEY_MAP = {
   item_limit: "itemLimit",
   index_limit: "indexLimit"
 };
-var IpcError = class extends Error {
+var IpcError2 = class extends Error {
   /** JSON-RPC error code. */
   code;
   constructor(code, message) {
@@ -1301,9 +2021,11 @@ var WorkerDaemon = class {
   }
   _connectionCount = 0;
   _wasmModules = null;
+  _embeddingProvider = null;
   _idleAt = 0;
   _idleTimer = null;
   _server = null;
+  _sockets = /* @__PURE__ */ new Set();
   _wasmDir;
   /** Queue of waiters for the single-writer lock. */
   _writeQueue = [];
@@ -1339,20 +2061,24 @@ var WorkerDaemon = class {
    *   catches this, prints to stderr, and exits with code 1
    */
   checkPreconditions() {
-    if (!(0, import_node_fs4.existsSync)(this.targetDir)) {
+    if (!(0, import_node_fs8.existsSync)(this.targetDir)) {
+      log(
+        `database directory not found: ${this.targetDir}`,
+        3 /* ERROR */
+      );
       throw new Error(
         `database directory not found: ${this.targetDir}`
       );
     }
     try {
-      (0, import_node_fs4.accessSync)(
+      (0, import_node_fs8.accessSync)(
         this.targetDir,
-        import_node_fs4.constants.R_OK | import_node_fs4.constants.W_OK
+        import_node_fs8.constants.R_OK | import_node_fs8.constants.W_OK
       );
     } catch {
-      throw new Error(
-        `cannot access database directory: ${this.targetDir} -- permission denied`
-      );
+      const msg = `cannot access database directory: ${this.targetDir} -- permission denied`;
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
     }
     this.checkCatalogVersion();
   }
@@ -1368,34 +2094,69 @@ var WorkerDaemon = class {
    *   be created
    */
   async start() {
+    log(
+      "start: loading wasm modules ctx=" + this.ctx,
+      0 /* DEBUG */
+    );
     const wasmModules = await loadWasmModules(
       this.config,
       this._wasmDir
     );
     this._wasmModules = wasmModules;
+    log("start: wasm modules loaded", 0 /* DEBUG */);
+    this._embeddingProvider = createEmbeddingProvider(
+      this.config.embedding,
+      wasmModules.embedding
+    );
+    log(
+      "start: embedding provider created embedding=" + (this.config.embedding?.provider ?? "none"),
+      0 /* DEBUG */
+    );
     this.initWorkerContext();
+    log("start: worker context initialized", 0 /* DEBUG */);
     this.runStartupIntegrityCheck();
-    const pidPath = (0, import_node_path6.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
-    (0, import_node_fs4.writeFileSync)(pidPath, process.pid.toString());
+    log(
+      "start: integrity check done ok=" + String(this._integrityOk),
+      0 /* DEBUG */
+    );
     const ipcPath = getIpcPath(this.ctx);
-    if ((0, import_node_fs4.existsSync)(ipcPath)) {
+    if ((0, import_node_fs8.existsSync)(ipcPath)) {
+      log("start: removing stale socket " + ipcPath, 0 /* DEBUG */);
       try {
-        (0, import_node_fs4.unlinkSync)(ipcPath);
+        (0, import_node_fs8.unlinkSync)(ipcPath);
       } catch {
       }
     }
     const handler = (req) => this.handleRequest(req);
-    this._server = createIpcServer(ipcPath, handler);
-    this._server.on("connection", () => {
+    this._server = await createIpcServer(ipcPath, handler);
+    log("IPC server listening on " + ipcPath, 1 /* INFO */);
+    this._server.on("connection", (socket) => {
+      this._sockets.add(socket);
       this.incrementConnections();
       this.resetIdleTimer();
+      log(
+        "client connected (count: " + String(this._connectionCount) + ")",
+        0 /* DEBUG */
+      );
+      socket.on("close", () => {
+        this._sockets.delete(socket);
+        this.decrementConnections();
+        log(
+          "client disconnected (count: " + String(this._connectionCount) + ")",
+          0 /* DEBUG */
+        );
+        if (this._connectionCount === 0) {
+          this.resetIdleTimer();
+        }
+      });
     });
-    this._server.on("close", () => {
-      this.decrementConnections();
-      if (this._connectionCount === 0) {
-        this.resetIdleTimer();
-      }
-    });
+    const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
+    (0, import_node_fs8.writeFileSync)(pidPath, process.pid.toString());
+    log(
+      "start: pid file written pid=" + String(process.pid),
+      0 /* DEBUG */
+    );
+    log("start: daemon ready ctx=" + this.ctx, 0 /* DEBUG */);
     this.resetIdleTimer();
   }
   /**
@@ -1406,30 +2167,44 @@ var WorkerDaemon = class {
    * the process.
    */
   stop() {
+    log(
+      "stop: entry sockets=" + String(this._sockets.size),
+      0 /* DEBUG */
+    );
+    log("shutting down", 1 /* INFO */);
     if (this._idleTimer !== null) {
       clearTimeout(this._idleTimer);
       this._idleTimer = null;
     }
+    for (const socket of this._sockets) {
+      socket.destroy();
+    }
+    this._sockets.clear();
     if (this._server !== null) {
       this._server.close();
       this._server = null;
+      log("stop: server closed", 0 /* DEBUG */);
     }
     this._wasmModules = null;
-    const pidPath = (0, import_node_path6.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
+    log("stop: wasm resources released", 0 /* DEBUG */);
+    const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.pid`);
     try {
-      (0, import_node_fs4.unlinkSync)(pidPath);
+      (0, import_node_fs8.unlinkSync)(pidPath);
+      log("stop: pid file removed", 0 /* DEBUG */);
     } catch {
     }
     const ipcPath = getIpcPath(this.ctx);
     try {
-      (0, import_node_fs4.unlinkSync)(ipcPath);
+      (0, import_node_fs8.unlinkSync)(ipcPath);
+      log("stop: socket file removed", 0 /* DEBUG */);
     } catch {
     }
-    const crashPath = (0, import_node_path6.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.crash`);
+    const crashPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${this.ctx}.crash`);
     try {
-      (0, import_node_fs4.unlinkSync)(crashPath);
+      (0, import_node_fs8.unlinkSync)(crashPath);
     } catch {
     }
+    log("stop: daemon exiting", 0 /* DEBUG */);
     process.exit(0);
   }
   /**
@@ -1443,8 +2218,16 @@ var WorkerDaemon = class {
    * @returns the JSON-RPC response
    */
   async handleRequest(request) {
+    log(
+      "handle-request: method=" + request.method + " id=" + String(request.id),
+      0 /* DEBUG */
+    );
     const params = request.params;
     if (params === void 0 || params.ctx !== this.ctx) {
+      log(
+        "handle-request: context mismatch id=" + String(request.id),
+        0 /* DEBUG */
+      );
       return this.errorResponse(
         request.id,
         -32001,
@@ -1455,6 +2238,10 @@ var WorkerDaemon = class {
     try {
       const result = await this.dispatch(request.method, params);
       this._idleAt = Math.floor(Date.now() / 1e3);
+      log(
+        "handle-request: success method=" + request.method + " id=" + String(request.id),
+        0 /* DEBUG */
+      );
       return {
         jsonrpc: "2.0",
         id: request.id,
@@ -1462,7 +2249,11 @@ var WorkerDaemon = class {
       };
     } catch (err) {
       this._idleAt = Math.floor(Date.now() / 1e3);
-      if (err instanceof IpcError) {
+      if (err instanceof IpcError2) {
+        log(
+          "handle-request: ipc error method=" + request.method + " id=" + String(request.id) + " code=" + String(err.code),
+          0 /* DEBUG */
+        );
         return this.errorResponse(
           request.id,
           err.code,
@@ -1470,6 +2261,10 @@ var WorkerDaemon = class {
         );
       }
       const message = err instanceof Error ? err.message : String(err);
+      log(
+        "handle-request: error method=" + request.method + " id=" + String(request.id),
+        0 /* DEBUG */
+      );
       return this.errorResponse(request.id, -32e3, message);
     }
   }
@@ -1513,37 +2308,45 @@ var WorkerDaemon = class {
       clearTimeout(this._idleTimer);
     }
     if (this._connectionCount === 0) {
+      log(
+        "idle timer started (" + String(this.config.timeoutMs) + "ms)",
+        0 /* DEBUG */
+      );
       this._idleTimer = setTimeout(() => {
+        log(
+          "idle timer fired: shutting down ctx=" + this.ctx,
+          0 /* DEBUG */
+        );
         this.stop();
       }, this.config.timeoutMs);
     }
   }
   /** Reads catalog.toml and validates the version field. */
   checkCatalogVersion() {
-    const catalogPath = (0, import_node_path6.join)(this.targetDir, "catalog.toml");
+    const catalogPath = (0, import_node_path9.join)(this.targetDir, "catalog.toml");
     let text;
     try {
-      text = (0, import_node_fs4.readFileSync)(catalogPath, "utf-8");
+      text = (0, import_node_fs8.readFileSync)(catalogPath, "utf-8");
     } catch {
-      throw new Error(
-        `cannot read database directory: ${this.targetDir} -- permission denied`
-      );
+      const msg = `cannot read database directory: ${this.targetDir} -- permission denied`;
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
     }
     const version = parseCatalogVersion(text);
     if (version === null) {
-      throw new Error(
-        "database version 0 requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon"
-      );
+      const msg = "database version 0 requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon";
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
     }
     if (version > DB_FORMAT_VERSION) {
-      throw new Error(
-        "database version " + String(version) + " is newer than kbdb version " + String(DB_FORMAT_VERSION) + " -- upgrade kbdb to open this database"
-      );
+      const msg = "database version " + String(version) + " is newer than kbdb version " + String(DB_FORMAT_VERSION) + " -- upgrade kbdb to open this database";
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
     }
     if (version < DB_FORMAT_VERSION) {
-      throw new Error(
-        "database version " + String(version) + " requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon"
-      );
+      const msg = "database version " + String(version) + " requires migration to version " + String(DB_FORMAT_VERSION) + " -- run `kbdb --migrate` before starting the daemon";
+      log(msg, 3 /* ERROR */);
+      throw new Error(msg);
     }
   }
   /** Builds a JSON-RPC error response. */
@@ -1582,7 +2385,7 @@ var WorkerDaemon = class {
     if (wasmMethod !== void 0) {
       return this.dispatchWasm(method, wasmMethod, params);
     }
-    throw new IpcError(-32601, `Method not found: ${method}`);
+    throw new IpcError2(-32601, `Method not found: ${method}`);
   }
   async dispatchWasm(method, wasmExport, params) {
     if (method === "search" || method === "query") {
@@ -1648,13 +2451,16 @@ var WorkerDaemon = class {
         return this.handleGc();
       }
       if (method === "rebuildIndexes" || method === "rebuild_indexes") {
-        return this.handleRebuild();
+        return await this.handleRebuild();
       }
       if (method === "initDirectory" || method === "init_directory") {
         return this.handleInitDirectory(params);
       }
+      if (method === "importDb" || method === "import_db") {
+        return await this.handleImport(params);
+      }
       if (method === "migrateDatabase") {
-        throw new IpcError(
+        throw new IpcError2(
           -32601,
           "migrateDatabase is not yet supported"
         );
@@ -1665,12 +2471,25 @@ var WorkerDaemon = class {
     }
   }
   // -- Search/query (token-based async) --
-  handleSearch(params) {
+  async handleSearch(params) {
     const query = params["query"] ?? "";
     const mode = params["mode"] ?? "and";
     const limit = Number(params["limit"] ?? 20);
     const offset = Number(params["offset"] ?? 0);
+    const algo = params["algo"] ?? "lexical";
     const encoded = encodeSearchParams(query, mode, limit, offset);
+    const start = Date.now();
+    const lexical = this.runLexicalSearch(encoded);
+    const fused = await fuseSearchResults(
+      lexical,
+      algo,
+      query,
+      this._embeddingProvider ?? void 0,
+      this.targetDir
+    );
+    return { ...fused, elapsed_ms: Date.now() - start };
+  }
+  runLexicalSearch(encoded) {
     const searchFn = this.getExport("worker_search");
     const ptr = this.wasmAlloc(encoded.length);
     this.wasmWrite(ptr, encoded);
@@ -1679,20 +2498,17 @@ var WorkerDaemon = class {
     const statusFn = this.getExport("worker_result_status");
     const status = statusFn(token);
     if (status === 3) {
-      const getResultFn2 = this.getExport("worker_get_result");
-      getResultFn2(token);
+      this.getExport("worker_get_result")(token);
       const errBytes = this.readReturnSlot();
-      const errMsg = new TextDecoder().decode(errBytes);
-      throw new IpcError(-32e3, errMsg);
+      throw new IpcError2(-32e3, new TextDecoder().decode(errBytes));
     }
     const getResultFn = this.getExport("worker_get_result");
     const rc = getResultFn(token);
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
-      throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
+      throw new IpcError2(-32e3, new TextDecoder().decode(errBytes));
     }
-    const resultBytes = this.readReturnSlot();
-    return decodePagedSearchResult(resultBytes);
+    return decodePagedSearchResult(this.readReturnSlot());
   }
   // -- Token status/result (u32 direct params) --
   handleResultStatus(params) {
@@ -1707,7 +2523,7 @@ var WorkerDaemon = class {
     const rc = fn(token);
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
-      throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
+      throw new IpcError2(-32e3, new TextDecoder().decode(errBytes));
     }
     const bytes = this.readReturnSlot();
     return decodePagedSearchResult(bytes);
@@ -1734,7 +2550,11 @@ var WorkerDaemon = class {
     const encoded = encodeAddSectionParams(input);
     const bytes = this.callWasmSync("worker_add_section", encoded);
     const decoded = decodeAddSectionResult(bytes);
-    const nearDups = decoded.nearDuplicates.length > 0 ? decoded.nearDuplicates : this.scanNearDuplicates(input.content, decoded.kbid);
+    const wasmDups = decoded.nearDuplicates;
+    const tsDups = wasmDups.length > 0 ? [] : this.scanNearDuplicates(input.content, decoded.kbid);
+    const nearDups = (wasmDups.length > 0 ? wasmDups : tsDups).map(
+      (d) => ({ ...d, method: "jaccard" })
+    );
     return {
       kbid: decoded.kbid,
       indexed_terms_count: decoded.indexedTermsCount,
@@ -1823,7 +2643,7 @@ var WorkerDaemon = class {
     this.wasmFree(ptr, encoded.length);
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
-      throw new IpcError(
+      throw new IpcError2(
         -32e3,
         new TextDecoder().decode(errBytes) || "invalidate failed"
       );
@@ -1862,7 +2682,12 @@ var WorkerDaemon = class {
     this.callWasmZeroArg("worker_status");
     const bytes = this.readReturnSlot();
     const text = new TextDecoder().decode(bytes);
-    return decodeKeyValueText(text);
+    const kv = decodeKeyValueText(text);
+    const mem = this._wasmModules?.memory;
+    if (mem) {
+      kv["wasm_memory_bytes"] = String(mem.buffer.byteLength);
+    }
+    return kv;
   }
   handleIntegrityCheck() {
     this.callWasmZeroArg("worker_check_integrity");
@@ -1885,13 +2710,13 @@ var WorkerDaemon = class {
       stale_sources: staleSources
     };
   }
-  handleRebuild() {
+  async handleRebuild() {
     const fn = this.getExport("worker_rebuild_indexes");
     const rc = fn();
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
       const errMsg = new TextDecoder().decode(errBytes);
-      throw new IpcError(-32e3, errMsg || "rebuild failed");
+      throw new IpcError2(-32e3, errMsg || "rebuild failed");
     }
     const resultBytes = this.readReturnSlot();
     const reindexed = resultBytes.length >= 4 ? new DataView(
@@ -1899,7 +2724,18 @@ var WorkerDaemon = class {
       resultBytes.byteOffset,
       resultBytes.byteLength
     ).getUint32(0, true) : 0;
-    return { ok: true, sections_reindexed: reindexed };
+    let vectorsRebuilt = 0;
+    if (this._embeddingProvider !== null) {
+      vectorsRebuilt = await rebuildVectors(
+        this.targetDir,
+        this._embeddingProvider
+      );
+    }
+    return {
+      ok: true,
+      sections_reindexed: reindexed,
+      vectors_rebuilt: vectorsRebuilt
+    };
   }
   // -- Export (read operation, no lock required) --
   handleExport(params) {
@@ -1917,14 +2753,57 @@ var WorkerDaemon = class {
       elapsed_ms: elapsed
     };
   }
+  async handleImport(params) {
+    const sourcePath = params["sourcePath"] ?? "";
+    const dryRun = params["dryRun"] === true;
+    const start = Date.now();
+    const sectionCount = this.countFiles(
+      (0, import_node_path9.join)(sourcePath, "sections"),
+      ".section"
+    );
+    const documentCount = this.countFiles(
+      (0, import_node_path9.join)(sourcePath, "documents"),
+      ".toml"
+    );
+    let rebuilt = false;
+    if (!dryRun && sectionCount > 0) {
+      await this.handleRebuild();
+      rebuilt = true;
+    }
+    return {
+      sections_imported: sectionCount,
+      documents_imported: documentCount,
+      rebuilt,
+      dry_run: dryRun,
+      elapsed_ms: Date.now() - start
+    };
+  }
+  countFiles(dir, ext) {
+    if (!(0, import_node_fs8.existsSync)(dir)) return 0;
+    return this.collectFiles(dir, ext).length;
+  }
+  collectFiles(dir, ext) {
+    const result = [];
+    for (const entry of (0, import_node_fs8.readdirSync)(dir, {
+      withFileTypes: true
+    })) {
+      const full = (0, import_node_path9.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        result.push(...this.collectFiles(full, ext));
+      } else if (entry.name.endsWith(ext)) {
+        result.push(full);
+      }
+    }
+    return result;
+  }
   // -- Near-duplicate detection --
   scanNearDuplicates(content, newKbid) {
     const newTerms = this.extractTermSet(content);
     if (newTerms.size === 0) return [];
-    const sectionsDir = (0, import_node_path6.join)(this.targetDir, "sections");
+    const sectionsDir = (0, import_node_path9.join)(this.targetDir, "sections");
     let shards;
     try {
-      shards = (0, import_node_fs4.readdirSync)(sectionsDir);
+      shards = (0, import_node_fs8.readdirSync)(sectionsDir);
     } catch {
       return [];
     }
@@ -1932,7 +2811,7 @@ var WorkerDaemon = class {
     for (const shard of shards) {
       let files;
       try {
-        files = (0, import_node_fs4.readdirSync)((0, import_node_path6.join)(sectionsDir, shard));
+        files = (0, import_node_fs8.readdirSync)((0, import_node_path9.join)(sectionsDir, shard));
       } catch {
         continue;
       }
@@ -1941,8 +2820,8 @@ var WorkerDaemon = class {
         const kbid = file.slice(0, -8);
         if (kbid === newKbid) continue;
         try {
-          const data = (0, import_node_fs4.readFileSync)(
-            (0, import_node_path6.join)(sectionsDir, shard, file),
+          const data = (0, import_node_fs8.readFileSync)(
+            (0, import_node_path9.join)(sectionsDir, shard, file),
             "utf-8"
           );
           const sep = data.indexOf("\n---\n");
@@ -1983,8 +2862,13 @@ var WorkerDaemon = class {
   acquireWriteLock() {
     if (!this._writeLocked) {
       this._writeLocked = true;
+      log("write-lock: acquired", 0 /* DEBUG */);
       return Promise.resolve();
     }
+    log(
+      "write-lock: queued depth=" + String(this._writeQueue.length + 1),
+      0 /* DEBUG */
+    );
     return new Promise((resolve2) => {
       this._writeQueue.push({ resolve: resolve2 });
     });
@@ -1998,9 +2882,14 @@ var WorkerDaemon = class {
   releaseWriteLock() {
     const next = this._writeQueue.shift();
     if (next !== void 0) {
+      log(
+        "write-lock: released to next waiter depth=" + String(this._writeQueue.length),
+        0 /* DEBUG */
+      );
       next.resolve();
     } else {
       this._writeLocked = false;
+      log("write-lock: released", 0 /* DEBUG */);
     }
   }
   // -- WASM lifecycle --
@@ -2025,26 +2914,29 @@ var WorkerDaemon = class {
       this._integrityOk = kv["ok"] === "true";
       if (!this._integrityOk) {
         this._integrityErrors = Object.entries(kv).filter(([k]) => k !== "ok").map(([k, v]) => `${k}=${v}`);
-        console.error(
-          "[kbdb-worker] startup integrity check failed:",
-          this._integrityErrors.join(", ")
+        log(
+          "[kbdb-worker] startup integrity check failed: " + this._integrityErrors.join(", "),
+          2 /* WARNING */
         );
       }
     } catch {
       this._integrityOk = false;
       this._integrityErrors = ["integrity_check_failed"];
-      console.error(
-        "[kbdb-worker] startup integrity check threw an error"
+      log(
+        "[kbdb-worker] startup integrity check threw an error",
+        2 /* WARNING */
       );
     }
   }
   // -- WASM bridge primitives --
   getExport(name) {
     if (this._wasmModules === null) {
+      log("WASM modules not loaded", 3 /* ERROR */);
       throw new Error("WASM modules not loaded");
     }
     const fn = this._wasmModules.kbWorker.exports[name];
     if (typeof fn !== "function") {
+      log(`WASM export not found: ${name}`, 3 /* ERROR */);
       throw new Error(`WASM export not found: ${name}`);
     }
     return fn;
@@ -2068,6 +2960,7 @@ var WorkerDaemon = class {
     if (!memory) return;
     const memView = new Uint8Array(memory.buffer);
     if (ptr + data.length > memView.length) {
+      log("WASM memory overflow", 3 /* ERROR */);
       throw new Error("WASM memory overflow");
     }
     memView.set(data, ptr);
@@ -2098,7 +2991,7 @@ var WorkerDaemon = class {
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
       const errMsg = new TextDecoder().decode(errBytes);
-      throw new IpcError(-32e3, errMsg || exportName + " failed");
+      throw new IpcError2(-32e3, errMsg || exportName + " failed");
     }
     return this.readReturnSlot();
   }
@@ -2108,7 +3001,7 @@ var WorkerDaemon = class {
     if (rc === -1) {
       const errBytes = this.readReturnSlot();
       const errMsg = new TextDecoder().decode(errBytes);
-      throw new IpcError(-32e3, errMsg || exportName + " failed");
+      throw new IpcError2(-32e3, errMsg || exportName + " failed");
     }
   }
   invokeWasmRaw(exportName, input) {
@@ -2116,10 +3009,10 @@ var WorkerDaemon = class {
   }
   handleCheckVersion(params) {
     const targetPath = typeof params.targetPath === "string" ? params.targetPath : this.targetDir;
-    const catalogPath = (0, import_node_path6.join)(targetPath, "catalog.toml");
+    const catalogPath = (0, import_node_path9.join)(targetPath, "catalog.toml");
     let text;
     try {
-      text = (0, import_node_fs4.readFileSync)(catalogPath, "utf-8");
+      text = (0, import_node_fs8.readFileSync)(catalogPath, "utf-8");
     } catch {
       return {
         status: "needs_migration",
@@ -2160,7 +3053,7 @@ var WorkerDaemon = class {
     const key = method.slice(CONFIG_PREFIX.length);
     const prop = CONFIG_KEY_MAP[key];
     if (prop === void 0) {
-      throw new IpcError(-32601, `Method not found: ${method}`);
+      throw new IpcError2(-32601, `Method not found: ${method}`);
     }
     return this.config[prop];
   }
@@ -2179,9 +3072,18 @@ function parseCatalogVersion(text) {
 
 // src/shared/worker-daemon/functions/start-daemon.function.ts
 async function startDaemon(contextPath, wasmDir2) {
+  log(
+    "start-daemon: entry contextPath=" + contextPath,
+    0 /* DEBUG */
+  );
   const config = readConfig(contextPath);
+  log(
+    "start-daemon: config loaded timeoutMs=" + String(config.timeoutMs) + " embedding=" + (config.embedding?.provider ?? "none"),
+    0 /* DEBUG */
+  );
   const hash = await computeSha256(contextPath);
   const contextId = hash.slice(0, 16);
+  log("start-daemon: contextId=" + contextId, 0 /* DEBUG */);
   const daemon = new WorkerDaemon(
     contextId,
     contextPath,
@@ -2192,48 +3094,69 @@ async function startDaemon(contextPath, wasmDir2) {
     daemon.checkPreconditions();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`kbdb-worker: ${message}`);
+    log(`kbdb-worker: ${message}`, 3 /* ERROR */);
     writeCrashLog(contextId, message);
     process.exit(1);
   }
+  log("preconditions passed", 0 /* DEBUG */);
   try {
     await daemon.start();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`kbdb-worker: ${message}`);
+    log(`kbdb-worker: ${message}`, 3 /* ERROR */);
     writeCrashLog(contextId, message);
     process.exit(1);
   }
+  log("daemon started", 1 /* INFO */);
+  log(
+    "start-daemon: registering SIGTERM/SIGINT handlers",
+    0 /* DEBUG */
+  );
   process.on("SIGTERM", () => {
+    log("start-daemon: SIGTERM received", 0 /* DEBUG */);
     daemon.stop();
   });
   process.on("SIGINT", () => {
+    log("start-daemon: SIGINT received", 0 /* DEBUG */);
     daemon.stop();
   });
 }
 function writeCrashLog(contextId, message) {
   try {
-    const crashPath = (0, import_node_path7.join)((0, import_node_os3.tmpdir)(), `kbdb-${contextId}.crash`);
+    const crashPath = (0, import_node_path10.join)((0, import_node_os3.tmpdir)(), `kbdb-${contextId}.crash`);
     const payload = JSON.stringify({
       error: message,
       timestamp: Date.now()
     });
-    (0, import_node_fs5.writeFileSync)(crashPath, payload);
+    (0, import_node_fs9.writeFileSync)(crashPath, payload);
   } catch {
   }
 }
 
 // src/shared/worker-daemon/functions/run-worker.function.ts
-var import_node_path8 = require("node:path");
-async function runWorker(argv, deps) {
-  const contextPath = argv[0];
+var import_node_path11 = require("node:path");
+
+// src/shared/log/functions/parse-log-level.function.ts
+var LOG_LEVEL_MAP = {
+  debug: 0 /* DEBUG */,
+  info: 1 /* INFO */,
+  warning: 2 /* WARNING */,
+  error: 3 /* ERROR */
+};
+function parseLogLevel(value) {
+  return LOG_LEVEL_MAP[value.toLowerCase()] ?? 2 /* WARNING */;
+}
+
+// src/shared/worker-daemon/functions/run-worker.function.ts
+async function runWorker(argv2, deps) {
+  const { contextPath, logLevel } = parseWorkerArgs(argv2);
   if (!contextPath) {
     return {
-      error: "usage: kbdb-worker <context-path>",
+      error: "usage: kbdb-worker <context-path> [--log-level <level>]",
       exitCode: 1
     };
   }
-  const resolved = (0, import_node_path8.resolve)(contextPath);
+  const resolved = (0, import_node_path11.resolve)(contextPath);
   if (!deps.existsSync(resolved)) {
     return {
       error: `error: path not found: ${resolved}`,
@@ -2241,28 +3164,85 @@ async function runWorker(argv, deps) {
     };
   }
   await deps.startDaemon(resolved, deps.wasmDir);
-  return { exitCode: 0 };
+  return { exitCode: 0, logLevel };
+}
+function parseWorkerArgs(argv2) {
+  let contextPath;
+  let logLevel;
+  for (let i = 0; i < argv2.length; i++) {
+    if (argv2[i] === "--log-level" && argv2[i + 1]) {
+      logLevel = parseLogLevel(argv2[++i]);
+    } else if (!contextPath) {
+      contextPath = argv2[i];
+    }
+  }
+  return { contextPath, logLevel };
+}
+
+// src/shared/log/functions/resolve-log-level.function.ts
+function resolveLogLevel(cliLevel) {
+  if (cliLevel !== void 0) {
+    return cliLevel;
+  }
+  const envValue = process.env["KBDB_LOG_LEVEL"];
+  if (envValue !== void 0) {
+    return parseLogLevel(envValue);
+  }
+  return DEFAULT_LOG_LEVEL;
+}
+
+// src/shared/log/functions/configure-log.function.ts
+function configureLog(config) {
+  setLogLevel(config.level);
+  if (config.outputs === void 0) {
+    return;
+  }
+  const levels = [
+    0 /* DEBUG */,
+    1 /* INFO */,
+    2 /* WARNING */,
+    3 /* ERROR */
+  ];
+  for (const level of levels) {
+    const output = config.outputs[level];
+    if (output !== void 0) {
+      setLogOutput(level, output.write);
+    }
+  }
 }
 
 // src/worker.ts
 var import_meta = {};
 var baseDir = resolveBaseDir(import_meta.url, import_meta.dirname);
 var wasmDir = resolveWasmDir(baseDir.scriptDir);
+var argv = getArgs();
+var cliLogLevel = extractLogLevel(argv);
+configureLog({ level: resolveLogLevel(cliLogLevel) });
+log("daemon process starting", 0 /* DEBUG */);
 async function main() {
-  const result = await runWorker(getArgs(), {
-    existsSync: import_node_fs6.existsSync,
+  const result = await runWorker(argv, {
+    existsSync: import_node_fs10.existsSync,
     startDaemon,
     wasmDir
   });
   if (result.error) {
-    console.error(result.error);
+    log(result.error, 3 /* ERROR */);
   }
   if (result.exitCode !== 0) {
     process.exitCode = result.exitCode;
   }
 }
 main().catch((err) => {
-  console.error(err);
+  const msg = err instanceof Error ? err.message : String(err);
+  log(msg, 3 /* ERROR */);
   process.exitCode = 1;
 });
+function extractLogLevel(args) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--log-level" && args[i + 1]) {
+      return parseLogLevel(args[i + 1]);
+    }
+  }
+  return void 0;
+}
 //# sourceMappingURL=kbdb-worker.cjs.map