@dikolab/kbdb 0.3.2 → 0.4.1

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) {
@@ -65,6 +69,26 @@ var SUPPORTED_EXTENSIONS = [
   ".adoc"
 ];
 
+// 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/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/cli/functions/parse-args.function.ts
 function parseArgs(argv) {
   const options = {
@@ -88,19 +112,31 @@ function parseArgs(argv) {
         }
         return options;
       case "--version":
-      case "-v":
         options.command = "version";
         return options;
+      case "-v":
+      case "--verbose": {
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          options.logLevel = parseLogLevel(next);
+          i++;
+        } else {
+          options.logLevel = 2 /* WARNING */;
+        }
+        break;
+      }
+      case "-vv":
+      case "--verbose-info":
+        options.logLevel = 1 /* INFO */;
+        break;
+      case "-vvv":
+      case "--verbose-debug":
+        options.logLevel = 0 /* DEBUG */;
+        break;
       case "--init":
-        console.error(
-          'warning: --init is deprecated, use "kbdb db init"'
-        );
         options.command = "init";
         break;
       case "--migrate":
-        console.error(
-          'warning: --migrate is deprecated, use "kbdb db migrate"'
-        );
         options.command = "migrate";
         break;
       case "--db":
@@ -109,6 +145,7 @@ function parseArgs(argv) {
       case "--format":
       case "-f":
         options.format = argv[++i] ?? DEFAULT_FORMAT;
+        options.formatExplicit = true;
         break;
       case "--mode":
       case "-m":
@@ -166,10 +203,31 @@ 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;
+      case "--non-interactive":
+        options.nonInteractive = true;
+        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);
@@ -240,8 +298,67 @@ function formatMcp(paged) {
   );
 }
 
+// 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/cli/functions/run-search.function.ts
 async function runSearch(client, options) {
+  log("searching: " + options.args.join(" "), 0 /* DEBUG */);
   const query = options.args.join(" ").trim();
   if (!query) {
     return {
@@ -258,8 +375,13 @@ async function runSearch(client, options) {
     mode: options.mode,
     limit: options.limit,
     offset: options.offset,
-    algo: options.algo
+    algo: options.algo,
+    relaxed: options.relaxed
   });
+  log(
+    "search returned " + results.total.toString() + " results",
+    0 /* DEBUG */
+  );
   return {
     items: results.items.map((r) => ({
       kbid: r.kbid,
@@ -278,13 +400,41 @@ 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) {
+    const msg = `no section matches prefix "${prefix}"`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
+  }
+  if (seen.size > 1) {
+    const msg = `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
+  }
+  return [...seen][0];
+}
+
 // src/shared/cli/functions/run-recall.function.ts
 var MAX_RECALL_DEPTH = 3;
 async function runRecall(client, options) {
+  log("running recall", 0 /* DEBUG */);
   if (options.args.length === 0) {
     return { error: "no kbid provided" };
   }
@@ -292,14 +442,18 @@ 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
 async function runExport(client, options) {
+  log("running export", 0 /* DEBUG */);
   const path = options.args[0];
   return client.export({ path });
 }
@@ -308,6 +462,10 @@ async function runExport(client, options) {
 var import_node_fs = require("node:fs");
 var import_node_path3 = require("node:path");
 async function runLearn(client, options, io) {
+  log(
+    "learning " + options.args.length.toString() + " targets",
+    0 /* DEBUG */
+  );
   const results = [];
   let stdinConsumed = false;
   const readStdin = io?.readStdin ?? readProcessStdin;
@@ -346,6 +504,10 @@ async function runLearn(client, options, io) {
       );
     }
   }
+  log(
+    "learned " + results.length.toString() + " sections",
+    0 /* DEBUG */
+  );
   return results;
 }
 function mapAddSectionResult(result, path, size) {
@@ -409,8 +571,10 @@ function isSupportedFile(path) {
 
 // src/shared/cli/functions/run-unlearn.function.ts
 async function runUnlearn(client, options) {
+  log("running unlearn", 0 /* DEBUG */);
   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 +583,11 @@ async function runUnlearn(client, options) {
 
 // src/shared/cli/functions/run-content.function.ts
 async function runContent(client, options) {
-  return client.content(options.args);
+  log("running content", 0 /* DEBUG */);
+  const resolved = await Promise.all(
+    options.args.map((a) => resolveKbidPrefix(a, client))
+  );
+  return client.content(resolved);
 }
 
 // src/shared/cli/functions/run-check.function.ts
@@ -433,6 +601,7 @@ function parseDivergentContent(encoded) {
   }).filter((entry) => entry.kbids.length > 0);
 }
 async function runCheck(client, _options) {
+  log("running check", 0 /* DEBUG */);
   const raw = await client.integrityCheck();
   return {
     ok: raw.ok,
@@ -447,11 +616,13 @@ async function runCheck(client, _options) {
 
 // src/shared/cli/functions/run-gc.function.ts
 async function runGc(client, _options) {
+  log("running gc", 0 /* DEBUG */);
   return client.gc();
 }
 
 // src/shared/cli/functions/run-rebuild.function.ts
 async function runRebuild(client, _options) {
+  log("running rebuild", 0 /* DEBUG */);
   return client.rebuildIndexes();
 }
 
@@ -459,9 +630,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
@@ -596,6 +778,7 @@ function createScaffold(dbDir) {
   (0, import_node_fs4.writeFileSync)((0, import_node_path6.join)(dbDir, ".gitignore"), GITIGNORE);
 }
 function runInit(options) {
+  log("running init", 0 /* DEBUG */);
   const basePath = options.dbPath ? (0, import_node_path6.resolve)(options.dbPath) : process.cwd();
   const dbDir = (0, import_node_path6.join)(basePath, ".kbdb");
   try {
@@ -647,11 +830,13 @@ function askReadline(question) {
 
 // src/shared/cli/functions/run-status.function.ts
 async function runStatus(client, _options) {
+  log("running status", 0 /* DEBUG */);
   return client.dbStatus();
 }
 
 // src/shared/cli/functions/run-db-init.function.ts
 function runDbInit(options, runInitFn) {
+  log("running db-init", 0 /* DEBUG */);
   const result = runInitFn(options);
   if (result.ok) {
     return {
@@ -671,6 +856,7 @@ function runDbInit(options, runInitFn) {
 
 // src/shared/cli/functions/run-db-migrate.function.ts
 async function runDbMigrate(client, options) {
+  log("running db-migrate", 0 /* DEBUG */);
   const dbPath = options.dbPath ?? process.cwd();
   return client.migrateDatabase(dbPath);
 }
@@ -698,6 +884,7 @@ function serializeSkillContent(skill) {
 
 // src/shared/cli/functions/run-skill-learn.function.ts
 async function runSkillLearn(client, options) {
+  log("running skill-learn", 0 /* DEBUG */);
   const name = options.name;
   if (!name) {
     return { error: "--name is required", exitCode: 1 };
@@ -728,6 +915,7 @@ async function runSkillLearn(client, options) {
 
 // src/shared/cli/functions/run-skill-list.function.ts
 async function runSkillList(client, _options) {
+  log("running skill-list", 0 /* DEBUG */);
   const records = await client.listByType("skill");
   const items = records.map((r) => {
     let argumentCount = 0;
@@ -755,9 +943,11 @@ async function runSkillList(client, _options) {
 function parseSkillContent(json) {
   const raw = JSON.parse(json);
   if (typeof raw["name"] !== "string" || !raw["name"]) {
+    log("skill name is required", 3 /* ERROR */);
     throw new Error("skill name is required");
   }
   if (typeof raw["body"] !== "string") {
+    log("skill body is required", 3 /* ERROR */);
     throw new Error("skill body is required");
   }
   return {
@@ -770,6 +960,7 @@ function parseSkillContent(json) {
 
 // src/shared/cli/functions/run-skill-get.function.ts
 async function runSkillGet(client, options) {
+  log("running skill-get", 0 /* DEBUG */);
   const identifier = options.args[0] ?? options.name;
   if (!identifier) {
     return {
@@ -806,6 +997,7 @@ async function runSkillGet(client, options) {
 
 // src/shared/cli/functions/run-skill-delete.function.ts
 async function runSkillDelete(client, options) {
+  log("running skill-delete", 0 /* DEBUG */);
   const kbid = options.args[0];
   if (!kbid) {
     return { error: "kbid is required", exitCode: 1 };
@@ -823,6 +1015,7 @@ async function runSkillDelete(client, options) {
 
 // src/shared/cli/functions/run-agent-create.function.ts
 async function runAgentCreate(client, options) {
+  log("running agent-create", 0 /* DEBUG */);
   const name = options.name;
   if (!name) {
     return { error: "--name is required", exitCode: 1 };
@@ -868,6 +1061,7 @@ async function runAgentCreate(client, options) {
 
 // src/shared/cli/functions/run-agent-list.function.ts
 async function runAgentList(client, _options) {
+  log("running agent-list", 0 /* DEBUG */);
   const docs = await client.listDocumentsByType("agent");
   const items = docs.map((d) => ({
     docid: d.docid,
@@ -924,6 +1118,7 @@ async function resolveSkills(client, skillRefs) {
   });
 }
 async function runAgentGet(client, options) {
+  log("running agent-get", 0 /* DEBUG */);
   const docid = options.args[0];
   if (!docid) {
     return { error: "docid is required", exitCode: 1 };
@@ -945,6 +1140,7 @@ async function runAgentGet(client, options) {
 
 // src/shared/cli/functions/run-agent-delete.function.ts
 async function runAgentDelete(client, options) {
+  log("running agent-delete", 0 /* DEBUG */);
   const docid = options.args[0];
   if (!docid) {
     return { error: "docid is required", exitCode: 1 };
@@ -956,8 +1152,23 @@ async function runAgentDelete(client, options) {
   };
 }
 
+// src/shared/cli/functions/run-import.function.ts
+async function runImport(client, options) {
+  const from = options.from;
+  if (!from) {
+    const msg = "import requires --from <path>";
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
+  }
+  return client.import({
+    from,
+    dryRun: options.dryRun === true
+  });
+}
+
 // src/shared/cli/functions/dispatch-command.function.ts
 async function dispatchCommand(client, options, io) {
+  log("dispatching command: " + options.command, 0 /* DEBUG */);
   switch (options.command) {
     case "learn":
       return handleLearn(client, options, io);
@@ -979,6 +1190,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":
@@ -1016,6 +1229,7 @@ async function dispatchCommand(client, options, io) {
       return result;
     }
     default:
+      log("unknown command: " + options.command, 2 /* WARNING */);
       return {
         error: `unknown command: ${options.command}`,
         exitCode: 1
@@ -1101,6 +1315,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 +1429,7 @@ async function hydrateSearchPreviews(client, paged) {
 }
 
 // src/shared/version/constants/version.constant.ts
-var VERSION = "0.2.2";
+var VERSION = "0.4.1";
 
 // src/shared/cli/functions/generate-help.function.ts
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
@@ -1218,7 +1446,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "mcp",
   "db",
   "skill",
-  "agent"
+  "agent",
+  "worker"
 ]);
 var GROUP_SUBCOMMANDS = {
   db: [
@@ -1236,6 +1465,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 +1537,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 +1586,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 +1773,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 +1940,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,244 +1973,196 @@ 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);
+// src/shared/worker-client/classes/worker-client.class.ts
+var import_node_net = require("node:net");
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_os = require("node:os");
+
+// src/shared/platform/functions/is-process-alive.function.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
-  if (options.command === "mcp") {
-    return handleMcp(options, deps2);
+}
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+function discoverDaemon(contextId) {
+  log("discovering daemon for context: " + contextId, 0 /* DEBUG */);
+  const pidPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.pid`);
+  if (!(0, import_node_fs5.existsSync)(pidPath)) {
+    log(
+      "no daemon PID file found for context: " + contextId,
+      0 /* DEBUG */
+    );
+    return null;
   }
-  if (options.command === "migrate" || options.command === "db-migrate") {
-    return handleMigrate(options, deps2);
+  const pidStr = (0, import_node_fs5.readFileSync)(pidPath, "utf-8").trim();
+  const pid = parseInt(pidStr, 10);
+  if (isNaN(pid) || !isProcessAlive(pid)) {
+    log(
+      "daemon process not alive for context: " + contextId,
+      0 /* DEBUG */
+    );
+    try {
+      (0, import_node_fs5.unlinkSync)(pidPath);
+    } catch {
+    }
+    return null;
   }
-  return handleDataCommand(options, deps2);
-}
-function handleInit(options, deps2) {
-  const result = deps2.runInit(options);
-  if (result.ok) {
-    return {
-      output: result.targetPath,
-      exitCode: 0
-    };
+  log("daemon found: pid=" + pid.toString(), 0 /* DEBUG */);
+  const socketPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.sock`);
+  const crashPath = (0, import_node_path7.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.crash`);
+  try {
+    (0, import_node_fs5.unlinkSync)(crashPath);
+  } catch {
   }
-  return {
-    error: `error: ${result.errorMessage ?? "init failed"}`,
-    exitCode: 1
-  };
+  return { pid, socketPath };
 }
-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
-    };
+
+// src/shared/worker-client/classes/worker-client.class.ts
+var WorkerClient = class {
+  /**
+   * @param socketPath - absolute path to the daemon's IPC socket
+   *   (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, requestTimeoutMs) {
+    this.socketPath = socketPath;
+    this.contextId = contextId;
+    this.requestTimeoutMs = requestTimeoutMs;
   }
-  const dbDir = deps2.findDb(rawDbPath);
-  if (!dbDir) {
-    return {
-      error: `error: no .kbdb database found at ${rawDbPath}`,
-      exitCode: 1
-    };
+  /** Underlying socket; `null` when not connected. */
+  socket = null;
+  /** Monotonically increasing request ID counter. */
+  nextId = 1;
+  /** Map of outstanding request IDs to their resolve/reject pairs. */
+  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;
   }
-  let client;
-  try {
-    client = await deps2.createWorkerClient({
-      contextPath: dbDir
-    });
-  } catch (err) {
-    return {
-      error: `error: ${errorToMessage(err)}`,
-      exitCode: 1
-    };
+  /**
+   * 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() {
+    log("connecting to " + this.socketPath, 0 /* DEBUG */);
+    const maxRetries = 5;
+    let delay = 50;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        await this.tryConnect();
+        log("connected", 0 /* DEBUG */);
+        return;
+      } catch (err) {
+        const code = err.code;
+        const retriable = code === "ENOENT" || code === "ECONNREFUSED";
+        if (!retriable || attempt === maxRetries) {
+          throw err;
+        }
+        log(
+          "connect retry: attempt=" + attempt.toString() + " code=" + code + " delay=" + delay.toString() + "ms",
+          0 /* DEBUG */
+        );
+        await new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 2, 1e3);
+      }
+    }
   }
-  try {
-    const gateResult = await versionGate(client, dbDir);
-    if (gateResult) return gateResult;
-    if (deps2.startMcpServer) {
-      await deps2.startMcpServer(dbDir);
+  /** Destroys the IPC socket and clears the connection state. */
+  disconnect() {
+    log("disconnecting client", 0 /* DEBUG */);
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
     }
-    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
-    };
+  /**
+   * Kills the daemon process and disconnects the client.
+   *
+   * Discovers the daemon via PID file and sends `SIGTERM`.
+   * Always disconnects the socket regardless of kill outcome.
+   */
+  killDaemon() {
+    const info = discoverDaemon(this.contextId);
+    log(
+      "killing daemon: pid=" + (info ? info.pid.toString() : "unknown"),
+      0 /* DEBUG */
+    );
+    if (info) {
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch {
+      }
+    }
+    this.disconnect();
   }
-  let client;
-  try {
-    client = await deps2.createWorkerClient({
-      contextPath: dbDir
+  /**
+   * Single connection attempt with keepalive and
+   * post-connect failure handlers.
+   */
+  async tryConnect() {
+    return new Promise((resolve4, reject) => {
+      const sock = (0, import_node_net.connect)(this.socketPath, () => {
+        sock.removeListener("error", reject);
+        sock.setKeepAlive(true, 3e4);
+        sock.on("error", (err) => {
+          log(
+            "socket error: code=" + (err.code ?? err.message),
+            0 /* DEBUG */
+          );
+          this.handleSocketFailure(err);
+        });
+        sock.on("close", () => {
+          log("socket closed", 0 /* DEBUG */);
+          if (this.pending.size > 0) {
+            this.handleSocketFailure(
+              new Error("connection closed")
+            );
+          }
+          this.socket = null;
+        });
+        this.socket = sock;
+        resolve4();
+      });
+      sock.on("error", reject);
+      sock.on("data", (chunk) => {
+        this.handleData(chunk.toString());
+      });
     });
-  } 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 {
-  /**
-   * @param socketPath - absolute path to the daemon's IPC socket
-   *   (or Windows named pipe path)
-   * @param contextId - 16-character context identifier sent as
-   *   `ctx` in every JSON-RPC request
-   */
-  constructor(socketPath, contextId) {
-    this.socketPath = socketPath;
-    this.contextId = contextId;
-  }
-  /** Underlying socket; `null` when not connected. */
-  socket = null;
-  /** Monotonically increasing request ID counter. */
-  nextId = 1;
-  /** Map of outstanding request IDs to their resolve/reject pairs. */
-  pending = /* @__PURE__ */ new Map();
-  /** Partial line buffer for split TCP/IPC frames. */
-  buffer = "";
   /**
-   * Establishes the IPC connection to the worker daemon.
-   *
-   * @throws {Error} if the connection cannot be established
+   * Rejects all pending calls and marks the client as
+   * disconnected.
    */
-  async connect() {
-    return new Promise((resolve4, reject) => {
-      this.socket = (0, import_node_net.connect)(this.socketPath, () => {
-        resolve4();
-      });
-      this.socket.on("error", (err) => {
-        reject(err);
-      });
-      this.socket.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;
+  handleSocketFailure(err) {
+    log(
+      "socket failure: pending=" + this.pending.size.toString() + " err=" + err.message,
+      0 /* DEBUG */
+    );
+    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 +2171,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 +2425,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
     });
   }
   /**
@@ -2227,14 +2455,35 @@ var WorkerClient = class {
       throw new Error("not connected");
     }
     const id = this.nextId++;
+    log(
+      "call: method=" + method + " id=" + id.toString(),
+      0 /* DEBUG */
+    );
     const request = {
       jsonrpc: "2.0",
       id,
       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);
+          log(
+            "request timeout after " + String(timeoutMs) + "ms",
+            2 /* WARNING */
+          );
+          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,15 +2504,33 @@ 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) {
+            log(
+              "response error: id=" + response.id.toString() + " code=" + response.error.code.toString(),
+              0 /* DEBUG */
+            );
             const err = new Error(response.error.message);
             err.code = response.error.code;
             pending.reject(err);
           } else {
+            log(
+              "response ok: id=" + response.id.toString(),
+              0 /* DEBUG */
+            );
             pending.resolve(response.result);
           }
+        } else {
+          log(
+            "unmatched response id=" + response.id.toString(),
+            0 /* DEBUG */
+          );
         }
-      } catch {
+      } catch (parseErr) {
+        log(
+          "json parse error: " + parseErr.message,
+          0 /* DEBUG */
+        );
       }
     }
   }
@@ -2275,13 +2542,15 @@ var import_node_path11 = require("node:path");
 var import_node_os4 = require("node:os");
 
 // src/shared/worker-client/functions/resolve-db-path.function.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
 function resolveDbPath(targetDir) {
-  const base = targetDir ? (0, import_node_path7.resolve)(targetDir) : process.cwd();
-  const dbPath = (0, import_node_path7.join)(base, ".kbdb");
-  if (!(0, import_node_fs5.existsSync)(dbPath)) {
-    throw new Error(`database not found: ${dbPath}`);
+  const base = targetDir ? (0, import_node_path8.resolve)(targetDir) : process.cwd();
+  const dbPath = (0, import_node_path8.join)(base, ".kbdb");
+  if (!(0, import_node_fs6.existsSync)(dbPath)) {
+    const msg = `database not found: ${dbPath}`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return dbPath;
 }
@@ -2300,129 +2569,531 @@ async function computeContextId(absolutePath) {
   return hash.slice(0, 16);
 }
 
-// src/shared/worker-client/functions/discover-daemon.function.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
-var import_node_os = require("node:os");
+// 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) {
+    const msg = "workerScript must be provided (resolve at entry point)";
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
+  }
+  const execPath = runtime2 === "deno" ? "deno" : process.execPath;
+  const logLevelEnv = process.env["KBDB_LOG_LEVEL"];
+  const logArgs = logLevelEnv ? ["--log-level", logLevelEnv] : [];
+  const args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath, ...logArgs] : [workerScript2, contextPath, ...logArgs];
+  log(
+    "spawning daemon: " + execPath + " " + args.join(" "),
+    0 /* DEBUG */
+  );
+  const child = (0, import_node_child_process.spawn)(execPath, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
 
-// src/shared/platform/functions/is-process-alive.function.ts
-function isProcessAlive(pid) {
+// 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) {
+  log("waiting for daemon: contextId=" + contextId, 0 /* DEBUG */);
+  const pidPath = (0, import_node_path9.join)((0, import_node_os2.tmpdir)(), `kbdb-${contextId}.pid`);
+  const start = Date.now();
+  let iteration = 0;
+  while (Date.now() - start < timeoutMs) {
+    if ((0, import_node_fs7.existsSync)(pidPath)) {
+      log("daemon PID file appeared", 0 /* DEBUG */);
+      return true;
+    }
+    iteration++;
+    if (iteration % 10 === 0) {
+      const elapsed2 = Date.now() - start;
+      log(
+        "still waiting for daemon: elapsed=" + elapsed2.toString() + "ms",
+        0 /* DEBUG */
+      );
+    }
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+  const elapsed = Date.now() - start;
+  log(
+    "timed out waiting for daemon: elapsed=" + elapsed.toString() + "ms",
+    0 /* DEBUG */
+  );
+  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);
+  log("create-worker-client: contextId=" + contextId, 0 /* DEBUG */);
+  const socketPath = getIpcPath(contextId);
+  let daemon = discoverDaemon(contextId);
+  if (daemon) {
+    log("daemon found: pid=" + daemon.pid.toString(), 0 /* DEBUG */);
+  } else {
+    log("no daemon found", 0 /* DEBUG */);
+  }
+  if (!daemon && options?.autoSpawn !== false) {
+    const runtime2 = detectRuntime();
+    log("auto-spawning daemon", 0 /* DEBUG */);
+    spawnDaemon(dbPath, runtime2, options?.workerScript);
+    log("waiting for daemon after spawn", 0 /* DEBUG */);
+    await waitForDaemon(contextId, options?.connectTimeoutMs);
+    daemon = discoverDaemon(contextId);
+  }
+  if (!daemon) {
+    const msg = `kbdb worker daemon did not start: ${readCrashReason(contextId)}`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
+  }
+  log("connecting to daemon", 0 /* DEBUG */);
+  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) {
+  log("running worker-stop", 0 /* DEBUG */);
+  const contextId = await computeContextId(dbDir);
+  const info = discoverDaemon(contextId);
+  if (!info) {
+    return { output: "no daemon running", exitCode: 0 };
+  }
+  log("pid found: " + info.pid.toString(), 0 /* DEBUG */);
+  try {
+    process.kill(info.pid, "SIGTERM");
+    log("sigterm sent to pid=" + info.pid.toString(), 0 /* DEBUG */);
+  } catch {
+    return {
+      error: "error: failed to stop daemon",
+      exitCode: 1
+    };
+  }
+  const deadline = Date.now() + 5e3;
+  let pollIteration = 0;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(info.pid, 0);
+    } catch {
+      log(
+        "process exited: pid=" + info.pid.toString(),
+        0 /* DEBUG */
+      );
+      break;
+    }
+    pollIteration++;
+    if (pollIteration % 5 === 0) {
+      log(
+        "waiting for exit: pid=" + info.pid.toString() + " poll=" + pollIteration.toString(),
+        0 /* DEBUG */
+      );
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (Date.now() >= deadline) {
+    log(
+      "timed out waiting for exit: pid=" + info.pid.toString(),
+      0 /* DEBUG */
+    );
+  }
+  return {
+    output: `stopped daemon (pid ${info.pid.toString()})`,
+    exitCode: 0
+  };
+}
+
+// src/shared/cli/functions/run-worker-restart.function.ts
+async function runWorkerRestart(dbDir) {
+  log("running worker-restart", 0 /* DEBUG */);
+  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++) {
+    log(
+      "retry-on-timeout: attempt=" + attempt.toString() + " max=" + maxRetries.toString(),
+      0 /* DEBUG */
+    );
+    const client = await createClient();
+    try {
+      const result = await operation(client);
+      log(
+        "retry-on-timeout: success on attempt=" + attempt.toString(),
+        0 /* DEBUG */
+      );
+      return { client, result };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "REQUEST_TIMEOUT" || attempt >= maxRetries) {
+        log(
+          "retry-on-timeout: non-retriable error code=" + String(code),
+          0 /* DEBUG */
+        );
+        client.disconnect();
+        throw err;
+      }
+      lastError = err;
+      if (client.killDaemon) {
+        log(
+          "retry " + String(attempt + 1) + "/" + String(maxRetries) + ": killing daemon",
+          2 /* WARNING */
+        );
+        client.killDaemon();
+      } else {
+        client.disconnect();
+      }
+    }
+  }
+  log(
+    "retry-on-timeout: all retries exhausted max=" + maxRetries.toString(),
+    0 /* DEBUG */
+  );
+  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/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/shared/cli/functions/run-cli.function.ts
+async function runCli(argv, deps2) {
+  const options = parseArgs(argv);
+  const logLevel = resolveLogLevel(options.logLevel);
+  configureLog({ level: logLevel });
+  log("command: " + options.command, 0 /* DEBUG */);
+  if (options.command === "init") {
+    log('--init is deprecated, use "kbdb db init"', 2 /* WARNING */);
+  }
+  if (options.command === "migrate") {
+    log(
+      '--migrate is deprecated, use "kbdb db migrate"',
+      2 /* WARNING */
+    );
+  }
+  const nonInteractive = options.nonInteractive || process.env["KBDB_NON_INTERACTIVE"] === "1" || process.env["KBDB_NON_INTERACTIVE"] === "true";
+  const effectiveDeps = nonInteractive ? { ...deps2, isStdinTty: () => false } : deps2;
+  if (!options.formatExplicit) {
+    options.format = effectiveDeps.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, effectiveDeps);
+  }
+  if (options.command === "mcp") {
+    return handleMcp(options, effectiveDeps);
+  }
+  if (options.command === "migrate" || options.command === "db-migrate") {
+    return handleMigrate(options, effectiveDeps);
+  }
+  if (options.command === "worker-stop") {
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerStop
+    );
+  }
+  if (options.command === "worker-restart") {
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerRestart
+    );
+  }
+  return handleDataCommand(options, effectiveDeps);
+}
+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 {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+    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();
   }
 }
-
-// src/shared/worker-client/functions/discover-daemon.function.ts
-function discoverDaemon(contextId) {
-  const pidPath = (0, import_node_path8.join)((0, import_node_os.tmpdir)(), `kbdb-${contextId}.pid`);
-  if (!(0, import_node_fs6.existsSync)(pidPath)) return null;
-  const pidStr = (0, import_node_fs6.readFileSync)(pidPath, "utf-8").trim();
-  const pid = parseInt(pidStr, 10);
-  if (isNaN(pid) || !isProcessAlive(pid)) {
-    try {
-      (0, import_node_fs6.unlinkSync)(pidPath);
-    } catch {
+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
+      };
     }
-    return null;
+    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 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`);
+  log("db path: " + dbDir, 0 /* DEBUG */);
+  const timeoutMs = resolveTimeoutMs(options);
+  const maxRetries = resolveRetryCount(options);
   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 { 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
+    };
   }
-  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)}`
-    );
+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 +3127,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"]
@@ -3136,6 +3811,7 @@ function asStringArray2(value) {
   return [];
 }
 async function handleToolCall(client, name, args) {
+  log("tool call: " + name, 0 /* DEBUG */);
   try {
     switch (name) {
       case "search":
@@ -3179,6 +3855,7 @@ async function handleToolCall(client, name, args) {
       case "auto-capture-review":
         return handleAutoCaptureReview();
       default:
+        log("unknown tool: " + name, 2 /* WARNING */);
         return {
           content: [
             {
@@ -3190,6 +3867,10 @@ async function handleToolCall(client, name, args) {
         };
     }
   } catch (err) {
+    log(
+      "tool call failed: " + name + ": " + (err instanceof Error ? err.message : String(err)),
+      3 /* ERROR */
+    );
     return {
       content: [
         {
@@ -3207,7 +3888,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,
@@ -3563,6 +4245,7 @@ async function handleResourceRead(client, uri) {
       ]
     };
   }
+  log(`Unknown resource URI: ${uri}`, 3 /* ERROR */);
   throw new Error(`Unknown resource URI: ${uri}`);
 }
 
@@ -3639,6 +4322,7 @@ async function handleAgentPrompt(name, client) {
   const agents = await client.listDocumentsByType("agent");
   const doc = agents.find((a) => a.title === agentName);
   if (!doc) {
+    log("agent not found: " + agentName, 3 /* ERROR */);
     throw new Error("agent not found: " + agentName);
   }
   const sections = doc.sections;
@@ -3683,6 +4367,7 @@ async function handleSkillPrompt(name, promptArgs, client) {
     }
   }
   if (matchContent === void 0) {
+    log(`Prompt not found: ${name}`, 3 /* ERROR */);
     throw new Error(`Prompt not found: ${name}`);
   }
   const parsed = JSON.parse(matchContent);
@@ -3774,6 +4459,131 @@ 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();
+    log("auto-capture trigger evaluated", 0 /* DEBUG */);
+    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;
+    log("auto-capture storing knowledge", 0 /* DEBUG */);
+    await client.addSection({
+      sectionType: "text/markdown",
+      content: text,
+      title: "Auto-captured knowledge"
+    });
+  } catch {
+    log("auto-capture error (non-fatal)", 0 /* DEBUG */);
+  }
+}
+
+// src/shared/auto-capture/functions/evaluate-trigger.function.ts
+function evaluateTrigger(config, state) {
+  log("evaluating auto-capture trigger conditions", 0 /* DEBUG */);
+  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() {
+    log("evaluating auto-capture trigger", 0 /* DEBUG */);
+    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() {
+    log("resetting auto-capture controller", 0 /* DEBUG */);
+    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,21 +4593,63 @@ 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) {
+      log("no client factory for reconnect", 3 /* ERROR */);
+      throw new Error("no client factory for reconnect");
+    }
+    this.client.disconnect();
+    this.client = await this.clientFactory();
+    log("MCP client reconnected", 0 /* DEBUG */);
+  }
+  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;
+        }
+        log(
+          "request timeout, reconnecting (attempt " + (attempt + 1).toString() + "/" + this.maxRetries.toString() + ")",
+          2 /* WARNING */
+        );
+        await this.reconnectClient();
+      }
+    }
   }
   async listen() {
     const rl = (0, import_node_readline2.createInterface)({
       input: process.stdin,
       terminal: false
     });
+    log("MCP server listening on stdin", 0 /* DEBUG */);
     let pending = Promise.resolve();
     await new Promise((resolve4) => {
       rl.on("line", (line) => {
@@ -3805,7 +4657,10 @@ var McpServer = class {
       });
       rl.on("close", () => {
         void pending.then(() => {
+          this.autoCaptureController?.reset();
+          this.autoCaptureController = null;
           this.client.disconnect();
+          log("MCP stdin closed", 0 /* DEBUG */);
           resolve4();
         });
       });
@@ -3869,6 +4724,7 @@ var McpServer = class {
    */
   async requestSampling(messages, maxTokens) {
     if (!this.hostCapabilities?.["sampling"]) {
+      log("Host does not support sampling", 3 /* ERROR */);
       throw new Error("Host does not support sampling");
     }
     return this.sendRequest("sampling/createMessage", {
@@ -3915,10 +4771,15 @@ var McpServer = class {
       return null;
     }
     const request = parsed;
+    log("MCP request: " + request.method, 0 /* DEBUG */);
     if (request.id === void 0) {
       if (request.method === "notifications/initialized" || request.method === "notifications/cancelled") {
         if (request.method === "notifications/initialized" && !this.initialized) {
           this.initialized = true;
+          log("MCP initialized", 1 /* INFO */);
+          if (this.autoCaptureConfig !== null) {
+            this.autoCaptureController = new AutoCaptureController(this.autoCaptureConfig);
+          }
           void this.runStartupHealthCheck();
         }
       }
@@ -3952,7 +4813,7 @@ var McpServer = class {
             protocolVersion: "2025-11-25",
             serverInfo: {
               name: "kbdb",
-              version: "0.1.0"
+              version: VERSION
             },
             capabilities: {
               tools: {},
@@ -3993,11 +4854,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 +4865,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 +4971,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 +5012,134 @@ 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) {
+  log("creating MCP server", 0 /* DEBUG */);
+  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,18 +5149,36 @@ 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) => {
+    log("starting MCP server", 1 /* INFO */);
     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
+      );
+      log("MCP server listening on stdio", 0 /* DEBUG */);
       await server.listen();
+      log("MCP server closed", 1 /* INFO */);
     } finally {
       client.disconnect();
     }
@@ -4170,7 +5190,7 @@ async function main() {
     console.log(result.output);
   }
   if (result.error) {
-    console.error(result.error);
+    log(result.error, 3 /* ERROR */);
   }
   if (result.exitCode !== 0) {
     process.exitCode = result.exitCode;
@@ -4178,7 +5198,7 @@ async function main() {
 }
 main().catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(`error: ${msg}`);
+  log("error: " + msg, 3 /* ERROR */);
   process.exitCode = 1;
 });
 //# sourceMappingURL=cli.cjs.map