@dikolab/kbdb 0.3.1 → 0.4.0

package/dist/cli.cjs

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 "use strict";
 
+// src/cli.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path12 = require("node:path");
+
 // src/shared/runtime/functions/detect-runtime.ts
 function detectRuntime() {
   if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
@@ -109,6 +113,7 @@ function parseArgs(argv) {
       case "--format":
       case "-f":
         options.format = argv[++i] ?? DEFAULT_FORMAT;
+        options.formatExplicit = true;
         break;
       case "--mode":
       case "-m":
@@ -166,10 +171,28 @@ function parseArgs(argv) {
       case "-c":
         options.content = true;
         break;
+      case "--relaxed":
+        options.relaxed = true;
+        break;
+      case "--from":
+        options.from = argv[++i];
+        break;
+      case "--dry-run":
+        options.dryRun = true;
+        break;
+      case "--export-format":
+        options.exportFormat = argv[++i] ?? "git";
+        break;
+      case "--timeout-ms":
+        options.timeoutMs = parseInt(argv[++i] ?? "", 10) || void 0;
+        break;
+      case "--retry":
+        options.retry = parseInt(argv[++i] ?? "", 10) || void 0;
+        break;
       default:
         if (!options.command) {
           options.command = arg;
-        } else if (!options.args.length && (options.command === "db" || options.command === "skill" || options.command === "agent")) {
+        } else if (!options.args.length && (options.command === "db" || options.command === "skill" || options.command === "agent" || options.command === "worker")) {
           options.command = `${options.command}-${arg}`;
         } else {
           options.args.push(arg);
@@ -258,7 +281,8 @@ async function runSearch(client, options) {
     mode: options.mode,
     limit: options.limit,
     offset: options.offset,
-    algo: options.algo
+    algo: options.algo,
+    relaxed: options.relaxed
   });
   return {
     items: results.items.map((r) => ({
@@ -278,10 +302,35 @@ async function runSearch(client, options) {
     offset: results.offset,
     limit: results.limit,
     has_more: results.has_more,
-    relaxed: results.relaxed ?? false
+    relaxed: results.relaxed ?? false,
+    elapsed_ms: results.elapsed_ms,
+    search_mode: results.search_mode,
+    retrieval_method: results.retrieval_method
   };
 }
 
+// src/shared/cli/functions/resolve-kbid-prefix.function.ts
+var SECTION_TYPES = ["text", "code", "image"];
+async function resolveKbidPrefix(prefix, client) {
+  if (prefix.length >= 26) return prefix;
+  const seen = /* @__PURE__ */ new Set();
+  for (const type of SECTION_TYPES) {
+    const records = await client.listByType(type);
+    for (const r of records) {
+      if (r.kbid.startsWith(prefix)) seen.add(r.kbid);
+    }
+  }
+  if (seen.size === 0) {
+    throw new Error(`no section matches prefix "${prefix}"`);
+  }
+  if (seen.size > 1) {
+    throw new Error(
+      `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`
+    );
+  }
+  return [...seen][0];
+}
+
 // src/shared/cli/functions/run-recall.function.ts
 var MAX_RECALL_DEPTH = 3;
 async function runRecall(client, options) {
@@ -292,10 +341,13 @@ async function runRecall(client, options) {
     MAX_RECALL_DEPTH,
     Math.max(0, options.depth ?? 0)
   );
-  if (options.args.length === 1) {
-    return client.recall({ kbid: options.args[0], depth });
+  const resolved = await Promise.all(
+    options.args.map((a) => resolveKbidPrefix(a, client))
+  );
+  if (resolved.length === 1) {
+    return client.recall({ kbid: resolved[0], depth });
   }
-  return client.recall({ kbids: options.args, depth });
+  return client.recall({ kbids: resolved, depth });
 }
 
 // src/shared/cli/functions/run-export.function.ts
@@ -410,7 +462,8 @@ function isSupportedFile(path) {
 // src/shared/cli/functions/run-unlearn.function.ts
 async function runUnlearn(client, options) {
   const results = [];
-  for (const kbid of options.args) {
+  for (const arg of options.args) {
+    const kbid = await resolveKbidPrefix(arg, client);
     const result = await client.removeSection(kbid);
     results.push({ kbid, removed: result.removed });
   }
@@ -419,7 +472,10 @@ async function runUnlearn(client, options) {
 
 // src/shared/cli/functions/run-content.function.ts
 async function runContent(client, options) {
-  return client.content(options.args);
+  const resolved = await Promise.all(
+    options.args.map((a) => resolveKbidPrefix(a, client))
+  );
+  return client.content(resolved);
 }
 
 // src/shared/cli/functions/run-check.function.ts
@@ -459,9 +515,20 @@ async function runRebuild(client, _options) {
 var import_node_fs2 = require("node:fs");
 var import_node_path4 = require("node:path");
 function findDb(dbPath) {
-  const base = dbPath ? (0, import_node_path4.resolve)(dbPath) : process.cwd();
-  const kbdbDir = (0, import_node_path4.join)(base, ".kbdb");
-  return (0, import_node_fs2.existsSync)(kbdbDir) ? kbdbDir : null;
+  if (dbPath) {
+    const target = (0, import_node_path4.join)((0, import_node_path4.resolve)(dbPath), ".kbdb");
+    return (0, import_node_fs2.existsSync)(target) ? target : null;
+  }
+  let current = process.cwd();
+  let parent = (0, import_node_path4.dirname)(current);
+  while (parent !== current) {
+    const candidate2 = (0, import_node_path4.join)(current, ".kbdb");
+    if ((0, import_node_fs2.existsSync)(candidate2)) return candidate2;
+    current = parent;
+    parent = (0, import_node_path4.dirname)(current);
+  }
+  const candidate = (0, import_node_path4.join)(current, ".kbdb");
+  return (0, import_node_fs2.existsSync)(candidate) ? candidate : null;
 }
 
 // src/shared/cli/functions/run-init.function.ts
@@ -956,6 +1023,18 @@ async function runAgentDelete(client, options) {
   };
 }
 
+// src/shared/cli/functions/run-import.function.ts
+async function runImport(client, options) {
+  const from = options.from;
+  if (!from) {
+    throw new Error("import requires --from <path>");
+  }
+  return client.import({
+    from,
+    dryRun: options.dryRun === true
+  });
+}
+
 // src/shared/cli/functions/dispatch-command.function.ts
 async function dispatchCommand(client, options, io) {
   switch (options.command) {
@@ -979,6 +1058,8 @@ async function dispatchCommand(client, options, io) {
       return handleStatus(client, options);
     case "export":
       return handleExport(client, options);
+    case "import":
+      return handleImport(client, options);
     case "db-init":
       return handleDbInit(options);
     case "db-migrate":
@@ -1101,6 +1182,20 @@ async function handleExport(client, options) {
     };
   }
 }
+async function handleImport(client, options) {
+  try {
+    const result = await runImport(client, options);
+    return {
+      output: JSON.stringify(result, null, 2),
+      exitCode: 0
+    };
+  } catch (err) {
+    return {
+      error: `import failed: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
+  }
+}
 async function handleContent(client, options) {
   try {
     const result = await runContent(client, options);
@@ -1201,7 +1296,7 @@ async function hydrateSearchPreviews(client, paged) {
 }
 
 // src/shared/version/constants/version.constant.ts
-var VERSION = "0.2.2";
+var VERSION = "0.4.0";
 
 // src/shared/cli/functions/generate-help.function.ts
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
@@ -1218,7 +1313,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "mcp",
   "db",
   "skill",
-  "agent"
+  "agent",
+  "worker"
 ]);
 var GROUP_SUBCOMMANDS = {
   db: [
@@ -1236,6 +1332,10 @@ var GROUP_SUBCOMMANDS = {
     ["list", "List all agents"],
     ["get", "Retrieve an agent by docid"],
     ["delete", "Remove an agent"]
+  ],
+  worker: [
+    ["stop", "Stop the worker daemon"],
+    ["restart", "Restart the worker daemon"]
   ]
 };
 function isKnownCommand(cmd) {
@@ -1304,6 +1404,10 @@ Agents:
    agent get           Retrieve an agent by docid
    agent delete        Remove an agent
 
+Worker:
+   worker stop         Stop the worker daemon
+   worker restart      Restart the worker daemon
+
 Server:
    mcp                 Start MCP server mode (stdio)
 
@@ -1349,7 +1453,8 @@ Run "kbdb ${group} <subcommand> --help" for details.
 var GROUP_DESCRIPTIONS = {
   db: "Database management",
   skill: "Skill management",
-  agent: "Agent management"
+  agent: "Agent management",
+  worker: "Worker daemon management"
 };
 var LEAF_HELP = {
   learn: `kbdb learn - Import content from files or stdin
@@ -1535,11 +1640,11 @@ Options:
    --db <path>         Path to .kbdb directory
 
 Environment:
-   KBDB_DIR            Fallback database path
+   KBDB_DB_DIR            Fallback database path
 
 Examples:
    kbdb mcp --db /path/to/project
-   KBDB_DIR=/path/to/project kbdb mcp
+   KBDB_DB_DIR=/path/to/project kbdb mcp
 `
 };
 var SUBCOMMAND_HELP = {
@@ -1702,6 +1807,28 @@ Output:
 
 Examples:
    kbdb agent delete agent-code-reviewer
+`,
+  "worker-stop": `kbdb worker stop - Stop the worker daemon
+
+Usage: kbdb worker stop [options]
+
+Options:
+   --db <path>         Path to .kbdb directory
+
+Examples:
+   kbdb worker stop
+   kbdb worker stop --db /path/to/project
+`,
+  "worker-restart": `kbdb worker restart - Restart the worker daemon
+
+Usage: kbdb worker restart [options]
+
+Options:
+   --db <path>         Path to .kbdb directory
+
+Examples:
+   kbdb worker restart
+   kbdb worker restart --db /path/to/project
 `
 };
 function generateSubcommandHelp(command, subcommand) {
@@ -1713,199 +1840,6 @@ function generateSubcommandHelp(command, subcommand) {
   return generateCommandHelp(command);
 }
 
-// src/shared/cli/functions/run-cli.function.ts
-async function runCli(argv, deps2) {
-  const options = parseArgs(argv);
-  if (options.command === "help" || !options.command) {
-    const helpCommand = options.args[0];
-    const helpSubcommand = options.args[1];
-    const helpText = generateHelp(helpCommand, helpSubcommand);
-    if (helpCommand && !isKnownCommand(helpCommand)) {
-      return { output: helpText, exitCode: 1 };
-    }
-    return { output: helpText, exitCode: 0 };
-  }
-  if (options.command === "version") {
-    return { output: VERSION, exitCode: 0 };
-  }
-  if (options.command === "init" || options.command === "db-init") {
-    return handleInit(options, deps2);
-  }
-  if (options.command === "mcp") {
-    return handleMcp(options, deps2);
-  }
-  if (options.command === "migrate" || options.command === "db-migrate") {
-    return handleMigrate(options, deps2);
-  }
-  return handleDataCommand(options, deps2);
-}
-function handleInit(options, deps2) {
-  const result = deps2.runInit(options);
-  if (result.ok) {
-    return {
-      output: result.targetPath,
-      exitCode: 0
-    };
-  }
-  return {
-    error: `error: ${result.errorMessage ?? "init failed"}`,
-    exitCode: 1
-  };
-}
-async function handleMcp(options, deps2) {
-  const rawDbPath = options.dbPath ?? process.env["KBDB_DIR"];
-  if (!rawDbPath) {
-    return {
-      error: "error: --db or KBDB_DIR required in MCP mode",
-      exitCode: 1
-    };
-  }
-  const dbDir = deps2.findDb(rawDbPath);
-  if (!dbDir) {
-    return {
-      error: `error: no .kbdb database found at ${rawDbPath}`,
-      exitCode: 1
-    };
-  }
-  let client;
-  try {
-    client = await deps2.createWorkerClient({
-      contextPath: dbDir
-    });
-  } catch (err) {
-    return {
-      error: `error: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
-  }
-  try {
-    const gateResult = await versionGate(client, dbDir);
-    if (gateResult) return gateResult;
-    if (deps2.startMcpServer) {
-      await deps2.startMcpServer(dbDir);
-    }
-    return { exitCode: 0 };
-  } catch (err) {
-    return {
-      error: `error: mcp failed: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
-  } finally {
-    client.disconnect();
-  }
-}
-async function handleMigrate(options, deps2) {
-  const dbDir = deps2.findDb(options.dbPath);
-  if (!dbDir) {
-    const basePath = options.dbPath ?? process.cwd();
-    return {
-      error: `error: no .kbdb database found at ${basePath}`,
-      exitCode: 1
-    };
-  }
-  let client;
-  try {
-    client = await deps2.createWorkerClient({
-      contextPath: dbDir
-    });
-  } catch (err) {
-    return {
-      error: `error: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
-  }
-  try {
-    const versionStatus = await client.checkVersion(dbDir);
-    if (versionStatus.status === "too_new") {
-      return {
-        error: `error: database version ${versionStatus.currentVersion.toString()} is newer than kbdb version ${versionStatus.requiredVersion.toString()} -- upgrade kbdb`,
-        exitCode: 1
-      };
-    }
-    if (versionStatus.status === "needs_migration") {
-      const migrateResult = await client.migrateDatabase(dbDir);
-      return {
-        output: JSON.stringify(migrateResult, null, 2),
-        exitCode: 0
-      };
-    }
-    return { output: "already up to date", exitCode: 0 };
-  } catch (err) {
-    return {
-      error: `error: migrate failed: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
-  } finally {
-    client.disconnect();
-  }
-}
-async function handleDataCommand(options, deps2) {
-  let dbDir = deps2.findDb(options.dbPath);
-  if (!dbDir) {
-    const basePath = options.dbPath ?? process.cwd();
-    if (!deps2.isStdinTty()) {
-      return {
-        error: `error: no .kbdb database found at ${basePath} -- run \`kbdb --init\` to create one`,
-        exitCode: 1
-      };
-    }
-    const answer = await deps2.promptUser(
-      `No .kbdb database found. Create one in ${basePath}? [y/N] `
-    );
-    if (answer.toLowerCase() !== "y") {
-      return {
-        error: "aborted: no database created",
-        exitCode: 1
-      };
-    }
-    const initResult = deps2.runInit(options);
-    if (!initResult.ok) {
-      return {
-        error: `error: ${initResult.errorMessage ?? "init failed"}`,
-        exitCode: 1
-      };
-    }
-    dbDir = initResult.targetPath;
-  }
-  let client;
-  try {
-    client = await deps2.createWorkerClient({
-      contextPath: dbDir
-    });
-  } catch (err) {
-    return {
-      error: `error: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
-  }
-  try {
-    const gateResult = await versionGate(client, dbDir);
-    if (gateResult) return gateResult;
-    return await dispatchCommand(client, options);
-  } finally {
-    client.disconnect();
-  }
-}
-async function versionGate(client, dbDir) {
-  const versionStatus = await client.checkVersion(dbDir);
-  if (versionStatus.status === "needs_migration") {
-    return {
-      error: "error: database needs migration -- run `kbdb --migrate`",
-      exitCode: 1
-    };
-  }
-  if (versionStatus.status === "too_new") {
-    return {
-      error: `error: database version ${versionStatus.currentVersion.toString()} is newer than kbdb version ${versionStatus.requiredVersion.toString()} -- upgrade kbdb`,
-      exitCode: 1
-    };
-  }
-  return null;
-}
-
-// src/shared/cli/constants/help-text.constant.ts
-var HELP_TEXT = generateHelp();
-
 // src/shared/worker-client/classes/worker-client.class.ts
 var import_node_net = require("node:net");
 var WorkerClient = class {
@@ -1914,10 +1848,13 @@ var WorkerClient = class {
    *   (or Windows named pipe path)
    * @param contextId - 16-character context identifier sent as
    *   `ctx` in every JSON-RPC request
+   * @param requestTimeoutMs - per-request timeout in ms
+   *   (0 or undefined disables the timeout)
    */
-  constructor(socketPath, contextId) {
+  constructor(socketPath, contextId, requestTimeoutMs) {
     this.socketPath = socketPath;
     this.contextId = contextId;
+    this.requestTimeoutMs = requestTimeoutMs;
   }
   /** Underlying socket; `null` when not connected. */
   socket = null;
@@ -1927,30 +1864,85 @@ var WorkerClient = class {
   pending = /* @__PURE__ */ new Map();
   /** Partial line buffer for split TCP/IPC frames. */
   buffer = "";
+  /** Whether the underlying socket is connected. */
+  get isConnected() {
+    return this.socket !== null;
+  }
   /**
    * Establishes the IPC connection to the worker daemon.
    *
+   * Retries up to 5 times with exponential backoff on
+   * transient errors (`ENOENT`, `ECONNREFUSED`).
+   *
    * @throws {Error} if the connection cannot be established
    */
   async connect() {
+    const maxRetries = 5;
+    let delay = 50;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        await this.tryConnect();
+        return;
+      } catch (err) {
+        const code = err.code;
+        const retriable = code === "ENOENT" || code === "ECONNREFUSED";
+        if (!retriable || attempt === maxRetries) {
+          throw err;
+        }
+        await new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 2, 1e3);
+      }
+    }
+  }
+  /** Destroys the IPC socket and clears the connection state. */
+  disconnect() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+  }
+  /**
+   * Single connection attempt with keepalive and
+   * post-connect failure handlers.
+   */
+  async tryConnect() {
     return new Promise((resolve4, reject) => {
-      this.socket = (0, import_node_net.connect)(this.socketPath, () => {
+      const sock = (0, import_node_net.connect)(this.socketPath, () => {
+        sock.removeListener("error", reject);
+        sock.setKeepAlive(true, 3e4);
+        sock.on("error", (err) => {
+          this.handleSocketFailure(err);
+        });
+        sock.on("close", () => {
+          if (this.pending.size > 0) {
+            this.handleSocketFailure(
+              new Error("connection closed")
+            );
+          }
+          this.socket = null;
+        });
+        this.socket = sock;
         resolve4();
       });
-      this.socket.on("error", (err) => {
-        reject(err);
-      });
-      this.socket.on("data", (chunk) => {
+      sock.on("error", reject);
+      sock.on("data", (chunk) => {
         this.handleData(chunk.toString());
       });
     });
   }
-  /** Destroys the IPC socket and clears the connection state. */
-  disconnect() {
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = null;
+  /**
+   * Rejects all pending calls and marks the client as
+   * disconnected.
+   */
+  handleSocketFailure(err) {
+    const sock = this.socket;
+    this.socket = null;
+    for (const [id, call] of this.pending) {
+      this.pending.delete(id);
+      if (call.timer) clearTimeout(call.timer);
+      call.reject(err);
     }
+    if (sock) sock.destroy();
   }
   /**
    * Searches the knowledge base.
@@ -1959,7 +1951,10 @@ var WorkerClient = class {
    * @returns paginated search results with metadata
    */
   async search(params) {
-    return this.call("search", params);
+    return this.call("search", {
+      ...params,
+      algo: params.algo
+    });
   }
   /**
    * Retrieves full content and context for one or more sections by
@@ -2210,7 +2205,20 @@ var WorkerClient = class {
    */
   async export(params) {
     return this.call("export", {
-      targetPath: params?.path || void 0
+      targetPath: params?.path || void 0,
+      format: params?.format
+    });
+  }
+  /**
+   * Imports an exported database from the given path.
+   *
+   * @param params - source path and dry-run flag
+   * @returns import report with counts and timing
+   */
+  async import(params) {
+    return this.call("importDb", {
+      sourcePath: params.from,
+      dryRun: params.dryRun
     });
   }
   /**
@@ -2233,8 +2241,21 @@ var WorkerClient = class {
       method,
       params: { ctx: this.contextId, ...params }
     };
+    const timeoutMs = this.requestTimeoutMs;
     return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+      const call = { resolve: resolve4, reject };
+      if (timeoutMs) {
+        call.timer = setTimeout(() => {
+          if (!this.pending.has(id)) return;
+          this.pending.delete(id);
+          const err = new Error(
+            `request timeout after ${String(timeoutMs)}ms`
+          );
+          err.code = "REQUEST_TIMEOUT";
+          reject(err);
+        }, timeoutMs);
+      }
+      this.pending.set(id, call);
       socket.write(JSON.stringify(request) + "\n");
     });
   }
@@ -2255,6 +2276,7 @@ var WorkerClient = class {
         const pending = this.pending.get(response.id);
         if (pending) {
           this.pending.delete(response.id);
+          if (pending.timer) clearTimeout(pending.timer);
           if (response.error) {
             const err = new Error(response.error.message);
             err.code = response.error.code;
@@ -2328,101 +2350,397 @@ function discoverDaemon(contextId) {
     }
     return null;
   }
-  const socketPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.sock`);
-  const crashPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.crash`);
+  const socketPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.sock`);
+  const crashPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.crash`);
+  try {
+    (0, import_node_fs6.unlinkSync)(crashPath);
+  } catch {
+  }
+  return { pid, socketPath };
+}
+
+// src/shared/worker-client/functions/spawn-daemon.function.ts
+var import_node_child_process = require("node:child_process");
+function spawnDaemon(contextPath, runtime2, workerScript2) {
+  if (!workerScript2) {
+    throw new Error(
+      "workerScript must be provided (resolve at entry point)"
+    );
+  }
+  const execPath = runtime2 === "deno" ? "deno" : process.execPath;
+  const args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath] : [workerScript2, contextPath];
+  const child = (0, import_node_child_process.spawn)(execPath, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+
+// src/shared/worker-client/functions/wait-for-daemon.function.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_node_os2 = require("node:os");
+var DEFAULT_TIMEOUT_MS = 1e4;
+var POLL_INTERVAL_MS = 100;
+async function waitForDaemon(contextId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${contextId}.pid`);
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if ((0, import_node_fs7.existsSync)(pidPath)) return true;
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+
+// src/shared/platform/functions/get-ipc-path.function.ts
+var import_node_path10 = require("node:path");
+
+// src/shared/platform/functions/get-tmpdir.function.ts
+var import_node_os3 = require("node:os");
+function getTmpdir() {
+  return (0, import_node_os3.tmpdir)();
+}
+
+// src/shared/platform/functions/get-ipc-path.function.ts
+function getIpcPath(ctx) {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\kbdb-${ctx}`;
+  }
+  return (0, import_node_path10.join)(getTmpdir(), `kbdb-${ctx}.sock`);
+}
+
+// src/shared/worker-client/functions/create-worker-client.function.ts
+async function createWorkerClient(options) {
+  const dbPath = options?.contextPath ?? resolveDbPath(options?.dbPath);
+  const contextId = await computeContextId(dbPath);
+  const socketPath = getIpcPath(contextId);
+  let daemon = discoverDaemon(contextId);
+  if (!daemon && options?.autoSpawn !== false) {
+    const runtime2 = detectRuntime();
+    spawnDaemon(dbPath, runtime2, options?.workerScript);
+    await waitForDaemon(contextId, options?.connectTimeoutMs);
+    daemon = discoverDaemon(contextId);
+  }
+  if (!daemon) {
+    throw new Error(
+      `kbdb worker daemon did not start: ${readCrashReason(contextId)}`
+    );
+  }
+  const client = new WorkerClient(
+    socketPath,
+    contextId,
+    options?.requestTimeoutMs
+  );
+  await client.connect();
+  return client;
+}
+function readCrashReason(contextId) {
+  const crashPath = (0, import_node_path11.join)((0, import_node_os4.tmpdir)(), `kbdb-${contextId}.crash`);
+  if (!(0, import_node_fs8.existsSync)(crashPath)) {
+    return "daemon failed to start (no details available)";
+  }
+  try {
+    const raw = (0, import_node_fs8.readFileSync)(crashPath, "utf-8");
+    const crash = JSON.parse(raw);
+    (0, import_node_fs8.unlinkSync)(crashPath);
+    return crash.error ?? "unknown error (crash log empty)";
+  } catch {
+    return "daemon failed to start (crash log unreadable)";
+  }
+}
+
+// src/shared/cli/functions/run-worker-stop.function.ts
+async function runWorkerStop(dbDir) {
+  const contextId = await computeContextId(dbDir);
+  const info = discoverDaemon(contextId);
+  if (!info) {
+    return { output: "no daemon running", exitCode: 0 };
+  }
+  try {
+    process.kill(info.pid, "SIGTERM");
+    return {
+      output: `stopped daemon (pid ${info.pid.toString()})`,
+      exitCode: 0
+    };
+  } catch {
+    return {
+      error: "error: failed to stop daemon",
+      exitCode: 1
+    };
+  }
+}
+
+// src/shared/cli/functions/run-worker-restart.function.ts
+async function runWorkerRestart(dbDir) {
+  const stopResult = await runWorkerStop(dbDir);
+  if (stopResult.exitCode !== 0) return stopResult;
+  return {
+    output: "daemon will restart on next command",
+    exitCode: 0
+  };
+}
+
+// src/shared/cli/functions/resolve-raw-db-path.function.ts
+function resolveRawDbPath(options) {
+  return options.dbPath ?? process.env["KBDB_DB_DIR"];
+}
+
+// src/shared/worker-client/functions/retry-on-timeout.function.ts
+async function retryOnTimeout(createClient, operation, maxRetries) {
+  let lastError = new Error("retryOnTimeout exhausted");
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const client = await createClient();
+    try {
+      const result = await operation(client);
+      return { client, result };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "REQUEST_TIMEOUT" || attempt >= maxRetries) {
+        client.disconnect();
+        throw err;
+      }
+      lastError = err;
+      client.disconnect();
+    }
+  }
+  throw lastError;
+}
+
+// src/shared/worker-client/constants/request-timeout.constant.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+
+// src/shared/worker-client/constants/retry-defaults.constant.ts
+var DEFAULT_RETRY_COUNT = 5;
+
+// src/shared/cli/functions/run-cli.function.ts
+async function runCli(argv, deps2) {
+  const options = parseArgs(argv);
+  if (!options.formatExplicit) {
+    options.format = deps2.isStdoutTty() ? "text" : "json";
+  }
+  if (options.command === "help" || !options.command) {
+    const helpCommand = options.args[0];
+    const helpSubcommand = options.args[1];
+    const helpText = generateHelp(helpCommand, helpSubcommand);
+    if (helpCommand && !isKnownCommand(helpCommand)) {
+      return { output: helpText, exitCode: 1 };
+    }
+    return { output: helpText, exitCode: 0 };
+  }
+  if (options.command === "version") {
+    return { output: VERSION, exitCode: 0 };
+  }
+  if (options.command === "init" || options.command === "db-init") {
+    return handleInit(options, deps2);
+  }
+  if (options.command === "mcp") {
+    return handleMcp(options, deps2);
+  }
+  if (options.command === "migrate" || options.command === "db-migrate") {
+    return handleMigrate(options, deps2);
+  }
+  if (options.command === "worker-stop") {
+    return handleWorkerLifecycle(options, deps2, runWorkerStop);
+  }
+  if (options.command === "worker-restart") {
+    return handleWorkerLifecycle(options, deps2, runWorkerRestart);
+  }
+  return handleDataCommand(options, deps2);
+}
+function handleInit(options, deps2) {
+  const result = deps2.runInit(options);
+  if (result.ok) {
+    return {
+      output: result.targetPath,
+      exitCode: 0
+    };
+  }
+  return {
+    error: `error: ${result.errorMessage ?? "init failed"}`,
+    exitCode: 1
+  };
+}
+function resolveTimeoutMs(options) {
+  return options.timeoutMs ?? (parseInt(process.env["KBDB_DAEMON_TIMEOUT"] ?? "", 10) || DEFAULT_REQUEST_TIMEOUT_MS);
+}
+function resolveRetryCount(options) {
+  return options.retry ?? (parseInt(process.env["KBDB_RETRY"] ?? "", 10) || DEFAULT_RETRY_COUNT);
+}
+async function handleMcp(options, deps2) {
+  const explicitPath = resolveRawDbPath(options);
+  const dbDir = deps2.findDb(explicitPath);
+  if (!dbDir) {
+    return {
+      error: "error: no .kbdb database found at " + (explicitPath ?? process.cwd()),
+      exitCode: 1
+    };
+  }
+  const timeoutMs = resolveTimeoutMs(options);
+  const maxRetries = resolveRetryCount(options);
+  let client;
+  try {
+    client = await deps2.createWorkerClient({
+      contextPath: dbDir,
+      requestTimeoutMs: timeoutMs
+    });
+  } catch (err) {
+    return {
+      error: `error: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
+  }
+  try {
+    const gateResult = await versionGate(client, dbDir);
+    if (gateResult) return gateResult;
+    if (deps2.startMcpServer) {
+      await deps2.startMcpServer(
+        dbDir,
+        () => deps2.createWorkerClient({
+          contextPath: dbDir,
+          requestTimeoutMs: timeoutMs
+        }),
+        maxRetries
+      );
+    }
+    return { exitCode: 0 };
+  } catch (err) {
+    return {
+      error: `error: mcp failed: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
+  } finally {
+    client.disconnect();
+  }
+}
+async function handleMigrate(options, deps2) {
+  const dbDir = deps2.findDb(options.dbPath);
+  if (!dbDir) {
+    const basePath = options.dbPath ?? process.cwd();
+    return {
+      error: `error: no .kbdb database found at ${basePath}`,
+      exitCode: 1
+    };
+  }
+  let client;
+  try {
+    client = await deps2.createWorkerClient({
+      contextPath: dbDir
+    });
+  } catch (err) {
+    return {
+      error: `error: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
+  }
   try {
-    (0, import_node_fs6.unlinkSync)(crashPath);
-  } catch {
+    const versionStatus = await client.checkVersion(dbDir);
+    if (versionStatus.status === "too_new") {
+      return {
+        error: `error: database version ${versionStatus.currentVersion.toString()} is newer than kbdb version ${versionStatus.requiredVersion.toString()} -- upgrade kbdb`,
+        exitCode: 1
+      };
+    }
+    if (versionStatus.status === "needs_migration") {
+      const migrateResult = await client.migrateDatabase(dbDir);
+      return {
+        output: JSON.stringify(migrateResult, null, 2),
+        exitCode: 0
+      };
+    }
+    return { output: "already up to date", exitCode: 0 };
+  } catch (err) {
+    return {
+      error: `error: migrate failed: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
+  } finally {
+    client.disconnect();
   }
-  return { pid, socketPath };
 }
-
-// src/shared/worker-client/functions/spawn-daemon.function.ts
-var import_node_child_process = require("node:child_process");
-function spawnDaemon(contextPath, runtime2, workerScript2) {
-  if (!workerScript2) {
-    throw new Error(
-      "workerScript must be provided (resolve at entry point)"
+async function handleDataCommand(options, deps2) {
+  const explicitPath = resolveRawDbPath(options);
+  let dbDir = deps2.findDb(explicitPath);
+  if (!dbDir) {
+    const basePath = explicitPath ?? process.cwd();
+    if (!deps2.isStdinTty()) {
+      return {
+        error: `error: no .kbdb database found at ${basePath} -- run \`kbdb --init\` to create one`,
+        exitCode: 1
+      };
+    }
+    const answer = await deps2.promptUser(
+      `No .kbdb database found. Create one in ${basePath}? [y/N] `
     );
+    if (answer.toLowerCase() !== "y") {
+      return {
+        error: "aborted: no database created",
+        exitCode: 1
+      };
+    }
+    const initResult = deps2.runInit(options);
+    if (!initResult.ok) {
+      return {
+        error: `error: ${initResult.errorMessage ?? "init failed"}`,
+        exitCode: 1
+      };
+    }
+    dbDir = initResult.targetPath;
   }
-  const execPath = runtime2 === "deno" ? "deno" : process.execPath;
-  const args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath] : [workerScript2, contextPath];
-  const child = (0, import_node_child_process.spawn)(execPath, args, {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-}
-
-// src/shared/worker-client/functions/wait-for-daemon.function.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = require("node:path");
-var import_node_os2 = require("node:os");
-var DEFAULT_TIMEOUT_MS = 1e4;
-var POLL_INTERVAL_MS = 100;
-async function waitForDaemon(contextId, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${contextId}.pid`);
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if ((0, import_node_fs7.existsSync)(pidPath)) return true;
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-  }
-  return false;
-}
-
-// src/shared/platform/functions/get-ipc-path.function.ts
-var import_node_path10 = require("node:path");
-
-// src/shared/platform/functions/get-tmpdir.function.ts
-var import_node_os3 = require("node:os");
-function getTmpdir() {
-  return (0, import_node_os3.tmpdir)();
-}
-
-// src/shared/platform/functions/get-ipc-path.function.ts
-function getIpcPath(ctx) {
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\kbdb-${ctx}`;
+  const timeoutMs = resolveTimeoutMs(options);
+  const maxRetries = resolveRetryCount(options);
+  try {
+    const { client, result } = await retryOnTimeout(
+      () => deps2.createWorkerClient({
+        contextPath: dbDir,
+        requestTimeoutMs: timeoutMs
+      }),
+      async (c) => {
+        const gateResult = await versionGate(c, dbDir);
+        if (gateResult) return gateResult;
+        return dispatchCommand(c, options);
+      },
+      maxRetries
+    );
+    client.disconnect();
+    return result;
+  } catch (err) {
+    return {
+      error: `error: ${errorToMessage(err)}`,
+      exitCode: 1
+    };
   }
-  return (0, import_node_path10.join)(getTmpdir(), `kbdb-${ctx}.sock`);
 }
-
-// src/shared/worker-client/functions/create-worker-client.function.ts
-async function createWorkerClient(options) {
-  const dbPath = options?.contextPath ?? resolveDbPath(options?.dbPath);
-  const contextId = await computeContextId(dbPath);
-  const socketPath = getIpcPath(contextId);
-  let daemon = discoverDaemon(contextId);
-  if (!daemon && options?.autoSpawn !== false) {
-    const runtime2 = detectRuntime();
-    spawnDaemon(dbPath, runtime2, options?.workerScript);
-    await waitForDaemon(contextId, options?.connectTimeoutMs);
-    daemon = discoverDaemon(contextId);
-  }
-  if (!daemon) {
-    throw new Error(
-      `kbdb worker daemon did not start: ${readCrashReason(contextId)}`
-    );
+async function handleWorkerLifecycle(options, deps2, action) {
+  const explicitPath = resolveRawDbPath(options);
+  const dbDir = deps2.findDb(explicitPath);
+  if (!dbDir) {
+    return {
+      error: "error: no .kbdb database found at " + (explicitPath ?? process.cwd()),
+      exitCode: 1
+    };
   }
-  const client = new WorkerClient(socketPath, contextId);
-  await client.connect();
-  return client;
+  return action(dbDir);
 }
-function readCrashReason(contextId) {
-  const crashPath = (0, import_node_path11.join)((0, import_node_os4.tmpdir)(), `kbdb-${contextId}.crash`);
-  if (!(0, import_node_fs8.existsSync)(crashPath)) {
-    return "daemon failed to start (no details available)";
+async function versionGate(client, dbDir) {
+  const versionStatus = await client.checkVersion(dbDir);
+  if (versionStatus.status === "needs_migration") {
+    return {
+      error: "error: database needs migration -- run `kbdb --migrate`",
+      exitCode: 1
+    };
   }
-  try {
-    const raw = (0, import_node_fs8.readFileSync)(crashPath, "utf-8");
-    const crash = JSON.parse(raw);
-    (0, import_node_fs8.unlinkSync)(crashPath);
-    return crash.error ?? "unknown error (crash log empty)";
-  } catch {
-    return "daemon failed to start (crash log unreadable)";
+  if (versionStatus.status === "too_new") {
+    return {
+      error: `error: database version ${versionStatus.currentVersion.toString()} is newer than kbdb version ${versionStatus.requiredVersion.toString()} -- upgrade kbdb`,
+      exitCode: 1
+    };
   }
+  return null;
 }
 
+// src/shared/cli/constants/help-text.constant.ts
+var HELP_TEXT = generateHelp();
+
 // src/shared/mcp/classes/mcp-server.class.ts
 var import_node_readline2 = require("node:readline");
 
@@ -2456,6 +2774,10 @@ function createToolDefinitions() {
             type: "string",
             enum: ["lexical", "vector", "hybrid"],
             description: "Search algorithm (default: lexical)"
+          },
+          relaxed: {
+            type: "boolean",
+            description: "Use relaxed (OR) matching when the strict query returns no results"
           }
         },
         required: ["query"]
@@ -3207,7 +3529,8 @@ async function handleSearch2(client, args) {
     mode: args["mode"],
     limit: args["limit"],
     offset: args["offset"],
-    algo: args["algo"]
+    algo: args["algo"],
+    relaxed: args["relaxed"]
   });
   const stripped = {
     ...results,
@@ -3774,6 +4097,125 @@ function shouldEmitLog(messageLevel, threshold) {
   return messageIndex >= thresholdIndex;
 }
 
+// src/shared/auto-capture/functions/build-capture-prompt.function.ts
+function buildCapturePrompt(recentContext) {
+  return "Review the following conversation context and identify factual knowledge worth storing in the knowledge base.\n\nRules:\n- Include durable facts, decisions, preferences, and corrections that would be useful in future sessions.\n- Exclude ephemeral, task-specific, or temporary information that has no lasting value.\n- Format each piece of extracted knowledge as a concise statement suitable for direct storage.\n- If no durable knowledge is found, respond with an empty list.\n\nConversation context:\n" + recentContext;
+}
+
+// src/shared/mcp/functions/has-sampling-capability.function.ts
+function hasSamplingCapability(hostCapabilities) {
+  if (hostCapabilities === null) return false;
+  return Boolean(hostCapabilities["sampling"]);
+}
+
+// src/shared/mcp/functions/run-auto-capture.function.ts
+function isSamplingResponse(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  const content = obj["content"];
+  if (typeof content !== "object" || content === null) return false;
+  return typeof content["text"] === "string";
+}
+async function runAutoCapture(controller, config, client, hostCapabilities, requestSampling) {
+  try {
+    const trigger = controller.evaluate();
+    if (!trigger.shouldCapture) return;
+    if (!hasSamplingCapability(hostCapabilities)) return;
+    const prompt = buildCapturePrompt("recent conversation context");
+    const messages = [
+      { role: "user", content: { type: "text", text: prompt } }
+    ];
+    const raw = await requestSampling(messages, 1024);
+    if (!isSamplingResponse(raw)) return;
+    const text = raw.content.text.trim();
+    if (!text) return;
+    if (config.dryRun) return;
+    await client.addSection({
+      sectionType: "text/markdown",
+      content: text,
+      title: "Auto-captured knowledge"
+    });
+  } catch {
+  }
+}
+
+// src/shared/auto-capture/functions/evaluate-trigger.function.ts
+function evaluateTrigger(config, state) {
+  if (!config.enabled) {
+    return {
+      shouldCapture: false,
+      reason: "auto-capture is disabled"
+    };
+  }
+  if (state.totalCapturesThisSession >= config.maxCapturesPerSession) {
+    return {
+      shouldCapture: false,
+      reason: "session capture limit reached"
+    };
+  }
+  const elapsed = state.lastCaptureTimestamp ? Date.now() - state.lastCaptureTimestamp : Infinity;
+  if (elapsed < config.minIntervalMs) {
+    return {
+      shouldCapture: false,
+      reason: "within minimum interval"
+    };
+  }
+  if (state.toolCallsSinceLastCapture < config.triggerAfterToolCalls) {
+    return {
+      shouldCapture: false,
+      reason: "tool call threshold not yet reached"
+    };
+  }
+  return { shouldCapture: true, reason: "trigger threshold met" };
+}
+
+// src/shared/auto-capture/classes/auto-capture-controller.class.ts
+var AutoCaptureController = class {
+  toolCallsSinceLastCapture = 0;
+  lastCaptureTimestamp = 0;
+  totalCapturesThisSession = 0;
+  config;
+  /** @param config - the auto-capture configuration to use */
+  constructor(config) {
+    this.config = config;
+  }
+  /** Record one tool call for trigger counting. */
+  recordToolCall() {
+    this.toolCallsSinceLastCapture += 1;
+  }
+  /**
+   * Evaluates the current state against the trigger criteria.
+   *
+   * When the trigger fires, advances the session counters so the
+   * next evaluation respects rate limiting and the session cap.
+   *
+   * @returns the trigger decision with a human-readable reason
+   */
+  evaluate() {
+    const trigger = evaluateTrigger(this.config, this.state());
+    if (trigger.shouldCapture) {
+      this.totalCapturesThisSession += 1;
+      this.lastCaptureTimestamp = Date.now();
+      this.toolCallsSinceLastCapture = 0;
+    }
+    return trigger;
+  }
+  /** Reset all counters, e.g. on client disconnect. */
+  reset() {
+    this.toolCallsSinceLastCapture = 0;
+    this.lastCaptureTimestamp = 0;
+    this.totalCapturesThisSession = 0;
+  }
+  /** Returns a snapshot of the current controller state. */
+  state() {
+    return {
+      toolCallsSinceLastCapture: this.toolCallsSinceLastCapture,
+      lastCaptureTimestamp: this.lastCaptureTimestamp,
+      totalCapturesThisSession: this.totalCapturesThisSession
+    };
+  }
+};
+
 // src/shared/mcp/constants/mcp-error-codes.constant.ts
 var PARSE_ERROR = -32700;
 var METHOD_NOT_FOUND = -32601;
@@ -3783,15 +4225,50 @@ var RESOURCE_NOT_FOUND = -32002;
 var McpServer = class {
   client;
   contextPath;
+  autoCaptureConfig;
+  clientFactory;
+  maxRetries;
+  autoCaptureController = null;
   initialized = false;
   hostCapabilities = null;
   logLevel = null;
   subscriptions = /* @__PURE__ */ new Set();
   nextRequestId = 1;
   pendingRequests = /* @__PURE__ */ new Map();
-  constructor(client, contextPath) {
+  /**
+   * @param client - worker client providing knowledge-base operations
+   * @param contextPath - absolute path to the `.kbdb` directory
+   * @param autoCaptureConfig - optional auto-capture configuration;
+   *   when provided the server activates auto-capture on connection
+   * @param clientFactory - creates a fresh worker client (for retry)
+   * @param maxRetries - max retries on REQUEST_TIMEOUT
+   */
+  constructor(client, contextPath, autoCaptureConfig, clientFactory, maxRetries) {
     this.client = client;
     this.contextPath = contextPath ?? "";
+    this.autoCaptureConfig = autoCaptureConfig ?? null;
+    this.clientFactory = clientFactory ?? null;
+    this.maxRetries = maxRetries ?? DEFAULT_RETRY_COUNT;
+  }
+  async reconnectClient() {
+    if (!this.clientFactory) {
+      throw new Error("no client factory for reconnect");
+    }
+    this.client.disconnect();
+    this.client = await this.clientFactory();
+  }
+  async withRetry(fn) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        const code = err.code;
+        if (code !== "REQUEST_TIMEOUT" || attempt >= this.maxRetries || !this.clientFactory) {
+          throw err;
+        }
+        await this.reconnectClient();
+      }
+    }
   }
   async listen() {
     const rl = (0, import_node_readline2.createInterface)({
@@ -3805,6 +4282,8 @@ var McpServer = class {
       });
       rl.on("close", () => {
         void pending.then(() => {
+          this.autoCaptureController?.reset();
+          this.autoCaptureController = null;
           this.client.disconnect();
           resolve4();
         });
@@ -3919,6 +4398,9 @@ var McpServer = class {
       if (request.method === "notifications/initialized" || request.method === "notifications/cancelled") {
         if (request.method === "notifications/initialized" && !this.initialized) {
           this.initialized = true;
+          if (this.autoCaptureConfig !== null) {
+            this.autoCaptureController = new AutoCaptureController(this.autoCaptureConfig);
+          }
           void this.runStartupHealthCheck();
         }
       }
@@ -3952,7 +4434,7 @@ var McpServer = class {
             protocolVersion: "2025-11-25",
             serverInfo: {
               name: "kbdb",
-              version: "0.1.0"
+              version: VERSION
             },
             capabilities: {
               tools: {},
@@ -3993,11 +4475,10 @@ var McpServer = class {
         const rawName = params["name"];
         const name = typeof rawName === "string" ? rawName : "";
         const args = params["arguments"] ?? {};
-        const result = await handleToolCall(
-          this.client,
-          name,
-          args
+        const result = await this.withRetry(
+          () => handleToolCall(this.client, name, args)
         );
+        this.afterToolCall();
         return { jsonrpc: "2.0", id, result };
       }
       case "resources/read": {
@@ -4005,9 +4486,8 @@ var McpServer = class {
         const rawUri = params["uri"];
         const uri = typeof rawUri === "string" ? rawUri : "";
         try {
-          const result = await handleResourceRead(
-            this.client,
-            uri
+          const result = await this.withRetry(
+            () => handleResourceRead(this.client, uri)
           );
           return { jsonrpc: "2.0", id, result };
         } catch (err) {
@@ -4112,6 +4592,23 @@ var McpServer = class {
     const json = JSON.stringify(response);
     process.stdout.write(json + "\n");
   }
+  /**
+   * Records a tool call in the auto-capture controller and fires
+   * a capture when the trigger condition is met.
+   */
+  afterToolCall() {
+    const ctrl = this.autoCaptureController;
+    const cfg = this.autoCaptureConfig;
+    if (ctrl === null || cfg === null) return;
+    ctrl.recordToolCall();
+    void runAutoCapture(
+      ctrl,
+      cfg,
+      this.client,
+      this.hostCapabilities,
+      (messages, maxTokens) => this.requestSampling(messages, maxTokens)
+    );
+  }
   /**
    * Runs an integrity check immediately after the MCP handshake
    * completes. Emits a `notifications/message` warning when the
@@ -4136,8 +4633,133 @@ var McpServer = class {
 };
 
 // src/shared/mcp/functions/create-mcp-server.function.ts
-function createMcpServer(client) {
-  return new McpServer(client);
+function createMcpServer(client, contextPath, autoCaptureConfig, clientFactory, maxRetries) {
+  return new McpServer(
+    client,
+    contextPath,
+    autoCaptureConfig,
+    clientFactory,
+    maxRetries
+  );
+}
+
+// src/shared/worker-daemon/constants/daemon-defaults.constant.ts
+var DEFAULT_ITEM_LIMIT = 1e3;
+var DEFAULT_INDEX_LIMIT = 100;
+var DEFAULT_TIMEOUT_MS2 = 3e5;
+var DEFAULT_ITEM_TTL_MS = 6e4;
+
+// 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_MS2;
+      break;
+    case "item_ttl_ms":
+      acc.itemTtlMs = parseInt(value, 10) || DEFAULT_ITEM_TTL_MS;
+      break;
+    default:
+      break;
+  }
+}
+function parseWorkerToml(text, 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_MS2,
+    itemTtlMs: DEFAULT_ITEM_TTL_MS
+  };
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    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();
+    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/cli.ts
@@ -4147,17 +4769,32 @@ var baseDir = resolveBaseDir(import_meta.url, import_meta.dirname);
 var workerScript = resolveWorkerScript(baseDir.scriptDir, runtime);
 var deps = {
   isStdinTty,
+  isStdoutTty: () => process.stdout.isTTY,
   promptUser,
   createWorkerClient: (opts) => createWorkerClient({ ...opts, workerScript }),
   findDb,
   runInit,
-  startMcpServer: async (contextPath) => {
+  startMcpServer: async (contextPath, clientFactory, maxRetries) => {
     const client = await createWorkerClient({
       contextPath,
       workerScript
     });
     try {
-      const server = createMcpServer(client);
+      const tomlPath = (0, import_node_path12.join)(contextPath, "worker.toml");
+      let autoCaptureConfig;
+      try {
+        const tomlText = (0, import_node_fs9.readFileSync)(tomlPath, "utf-8");
+        const daemonConfig = parseWorkerToml(tomlText, contextPath);
+        autoCaptureConfig = daemonConfig.autoCapture;
+      } catch {
+      }
+      const server = createMcpServer(
+        client,
+        contextPath,
+        autoCaptureConfig,
+        clientFactory,
+        maxRetries
+      );
       await server.listen();
     } finally {
       client.disconnect();