@dikolab/kbdb 0.4.0 → 0.4.1

package/dist/cli.mjs

@@ -1,12 +1,16 @@
 import {
   computeSha256,
+  configureLog,
   detectRuntime,
   getArgs,
   getIpcPath,
+  log,
+  parseLogLevel,
   parseWorkerToml,
   resolveBaseDir,
+  resolveLogLevel,
   resolveWorkerScript
-} from "./chunk-BJPSPNGX.mjs";
+} from "./chunk-BJXEVALU.mjs";
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "node:fs";
@@ -46,19 +50,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":
@@ -143,6 +159,9 @@ function parseArgs(argv) {
       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;
@@ -219,6 +238,7 @@ function formatMcp(paged) {
 
 // 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 {
@@ -238,6 +258,10 @@ async function runSearch(client, options) {
     algo: options.algo,
     relaxed: options.relaxed
   });
+  log(
+    "search returned " + results.total.toString() + " results",
+    0 /* DEBUG */
+  );
   return {
     items: results.items.map((r) => ({
       kbid: r.kbid,
@@ -275,12 +299,14 @@ async function resolveKbidPrefix(prefix, client) {
     }
   }
   if (seen.size === 0) {
-    throw new Error(`no section matches prefix "${prefix}"`);
+    const msg = `no section matches prefix "${prefix}"`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   if (seen.size > 1) {
-    throw new Error(
-      `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`
-    );
+    const msg = `ambiguous prefix "${prefix}": ${seen.size.toString()} matches`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return [...seen][0];
 }
@@ -288,6 +314,7 @@ async function resolveKbidPrefix(prefix, client) {
 // 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" };
   }
@@ -306,6 +333,7 @@ async function runRecall(client, options) {
 
 // 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 });
 }
@@ -314,6 +342,10 @@ async function runExport(client, options) {
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, extname, join } from "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;
@@ -352,6 +384,10 @@ async function runLearn(client, options, io) {
       );
     }
   }
+  log(
+    "learned " + results.length.toString() + " sections",
+    0 /* DEBUG */
+  );
   return results;
 }
 function mapAddSectionResult(result, path, size) {
@@ -415,6 +451,7 @@ 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 arg of options.args) {
     const kbid = await resolveKbidPrefix(arg, client);
@@ -426,6 +463,7 @@ async function runUnlearn(client, options) {
 
 // src/shared/cli/functions/run-content.function.ts
 async function runContent(client, options) {
+  log("running content", 0 /* DEBUG */);
   const resolved = await Promise.all(
     options.args.map((a) => resolveKbidPrefix(a, client))
   );
@@ -443,6 +481,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,
@@ -457,11 +496,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();
 }
 
@@ -617,6 +658,7 @@ function createScaffold(dbDir) {
   writeFileSync2(join4(dbDir, ".gitignore"), GITIGNORE);
 }
 function runInit(options) {
+  log("running init", 0 /* DEBUG */);
   const basePath = options.dbPath ? resolve2(options.dbPath) : process.cwd();
   const dbDir = join4(basePath, ".kbdb");
   try {
@@ -668,11 +710,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 {
@@ -692,6 +736,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);
 }
@@ -719,6 +764,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 };
@@ -749,6 +795,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;
@@ -776,9 +823,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 {
@@ -791,6 +840,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 {
@@ -827,6 +877,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 };
@@ -844,6 +895,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 };
@@ -889,6 +941,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,
@@ -945,6 +998,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 };
@@ -966,6 +1020,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 };
@@ -981,7 +1036,9 @@ async function runAgentDelete(client, options) {
 async function runImport(client, options) {
   const from = options.from;
   if (!from) {
-    throw new Error("import requires --from <path>");
+    const msg = "import requires --from <path>";
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return client.import({
     from,
@@ -991,6 +1048,7 @@ async function runImport(client, options) {
 
 // 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);
@@ -1051,6 +1109,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
@@ -1250,7 +1309,7 @@ async function hydrateSearchPreviews(client, paged) {
 }
 
 // src/shared/version/constants/version.constant.ts
-var VERSION = "0.4.0";
+var VERSION = "0.4.1";
 
 // src/shared/cli/functions/generate-help.function.ts
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
@@ -1796,6 +1855,57 @@ function generateSubcommandHelp(command, subcommand) {
 
 // src/shared/worker-client/classes/worker-client.class.ts
 import { connect } from "node:net";
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, unlinkSync } from "node:fs";
+import { join as join5 } from "node:path";
+import { tmpdir } from "node:os";
+
+// src/shared/platform/functions/is-process-alive.function.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/shared/worker-client/functions/discover-daemon.function.ts
+function discoverDaemon(contextId) {
+  log("discovering daemon for context: " + contextId, 0 /* DEBUG */);
+  const pidPath = join5(tmpdir(), `kbdb-${contextId}.pid`);
+  if (!existsSync4(pidPath)) {
+    log(
+      "no daemon PID file found for context: " + contextId,
+      0 /* DEBUG */
+    );
+    return null;
+  }
+  const pidStr = readFileSync2(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 {
+      unlinkSync(pidPath);
+    } catch {
+    }
+    return null;
+  }
+  log("daemon found: pid=" + pid.toString(), 0 /* DEBUG */);
+  const socketPath = join5(tmpdir(), `kbdb-${contextId}.sock`);
+  const crashPath = join5(tmpdir(), `kbdb-${contextId}.crash`);
+  try {
+    unlinkSync(crashPath);
+  } catch {
+  }
+  return { pid, socketPath };
+}
+
+// src/shared/worker-client/classes/worker-client.class.ts
 var WorkerClient = class {
   /**
    * @param socketPath - absolute path to the daemon's IPC socket
@@ -1831,11 +1941,13 @@ var WorkerClient = class {
    * @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;
@@ -1843,6 +1955,10 @@ var WorkerClient = class {
         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);
       }
@@ -1850,11 +1966,32 @@ var WorkerClient = class {
   }
   /** Destroys the IPC socket and clears the connection state. */
   disconnect() {
+    log("disconnecting client", 0 /* DEBUG */);
     if (this.socket) {
       this.socket.destroy();
       this.socket = null;
     }
   }
+  /**
+   * 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();
+  }
   /**
    * Single connection attempt with keepalive and
    * post-connect failure handlers.
@@ -1865,9 +2002,14 @@ var WorkerClient = class {
         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")
@@ -1889,6 +2031,10 @@ var WorkerClient = class {
    * disconnected.
    */
   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) {
@@ -2189,6 +2335,10 @@ 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,
@@ -2202,6 +2352,10 @@ var WorkerClient = class {
         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`
           );
@@ -2232,14 +2386,31 @@ var WorkerClient = class {
           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 */
+        );
       }
     }
   }
@@ -2251,13 +2422,15 @@ import { join as join8 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 
 // src/shared/worker-client/functions/resolve-db-path.function.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join5, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join6, resolve as resolve3 } from "node:path";
 function resolveDbPath(targetDir) {
   const base = targetDir ? resolve3(targetDir) : process.cwd();
-  const dbPath = join5(base, ".kbdb");
-  if (!existsSync4(dbPath)) {
-    throw new Error(`database not found: ${dbPath}`);
+  const dbPath = join6(base, ".kbdb");
+  if (!existsSync5(dbPath)) {
+    const msg = `database not found: ${dbPath}`;
+    log(msg, 3 /* ERROR */);
+    throw new Error(msg);
   }
   return dbPath;
 }
@@ -2268,53 +2441,22 @@ async function computeContextId(absolutePath) {
   return hash.slice(0, 16);
 }
 
-// src/shared/worker-client/functions/discover-daemon.function.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2, unlinkSync } from "node:fs";
-import { join as join6 } from "node:path";
-import { tmpdir } from "node:os";
-
-// src/shared/platform/functions/is-process-alive.function.ts
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/shared/worker-client/functions/discover-daemon.function.ts
-function discoverDaemon(contextId) {
-  const pidPath = join6(tmpdir(), `kbdb-${contextId}.pid`);
-  if (!existsSync5(pidPath)) return null;
-  const pidStr = readFileSync2(pidPath, "utf-8").trim();
-  const pid = parseInt(pidStr, 10);
-  if (isNaN(pid) || !isProcessAlive(pid)) {
-    try {
-      unlinkSync(pidPath);
-    } catch {
-    }
-    return null;
-  }
-  const socketPath = join6(tmpdir(), `kbdb-${contextId}.sock`);
-  const crashPath = join6(tmpdir(), `kbdb-${contextId}.crash`);
-  try {
-    unlinkSync(crashPath);
-  } catch {
-  }
-  return { pid, socketPath };
-}
-
 // src/shared/worker-client/functions/spawn-daemon.function.ts
 import { spawn } from "node:child_process";
 function spawnDaemon(contextPath, runtime2, workerScript2) {
   if (!workerScript2) {
-    throw new Error(
-      "workerScript must be provided (resolve at entry point)"
-    );
+    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 args = runtime2 === "deno" ? ["run", "--allow-all", workerScript2, contextPath] : [workerScript2, contextPath];
+  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 = spawn(execPath, args, {
     detached: true,
     stdio: "ignore"
@@ -2329,12 +2471,30 @@ import { tmpdir as tmpdir2 } from "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 = join7(tmpdir2(), `kbdb-${contextId}.pid`);
   const start = Date.now();
+  let iteration = 0;
   while (Date.now() - start < timeoutMs) {
-    if (existsSync6(pidPath)) return true;
+    if (existsSync6(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;
 }
 
@@ -2342,19 +2502,28 @@ async function waitForDaemon(contextId, timeoutMs = DEFAULT_TIMEOUT_MS) {
 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) {
-    throw new Error(
-      `kbdb worker daemon did not start: ${readCrashReason(contextId)}`
-    );
+    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,
@@ -2380,27 +2549,58 @@ function readCrashReason(contextId) {
 
 // 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");
-    return {
-      output: `stopped daemon (pid ${info.pid.toString()})`,
-      exitCode: 0
-    };
+    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 {
@@ -2418,20 +2618,44 @@ function resolveRawDbPath(options) {
 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;
-      client.disconnect();
+      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;
 }
 
@@ -2444,8 +2668,22 @@ var DEFAULT_RETRY_COUNT = 5;
 // 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 = deps2.isStdoutTty() ? "text" : "json";
+    options.format = effectiveDeps.isStdoutTty() ? "text" : "json";
   }
   if (options.command === "help" || !options.command) {
     const helpCommand = options.args[0];
@@ -2460,21 +2698,29 @@ async function runCli(argv, deps2) {
     return { output: VERSION, exitCode: 0 };
   }
   if (options.command === "init" || options.command === "db-init") {
-    return handleInit(options, deps2);
+    return handleInit(options, effectiveDeps);
   }
   if (options.command === "mcp") {
-    return handleMcp(options, deps2);
+    return handleMcp(options, effectiveDeps);
   }
   if (options.command === "migrate" || options.command === "db-migrate") {
-    return handleMigrate(options, deps2);
+    return handleMigrate(options, effectiveDeps);
   }
   if (options.command === "worker-stop") {
-    return handleWorkerLifecycle(options, deps2, runWorkerStop);
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerStop
+    );
   }
   if (options.command === "worker-restart") {
-    return handleWorkerLifecycle(options, deps2, runWorkerRestart);
+    return handleWorkerLifecycle(
+      options,
+      effectiveDeps,
+      runWorkerRestart
+    );
   }
-  return handleDataCommand(options, deps2);
+  return handleDataCommand(options, effectiveDeps);
 }
 function handleInit(options, deps2) {
   const result = deps2.runInit(options);
@@ -2615,6 +2861,7 @@ async function handleDataCommand(options, deps2) {
     }
     dbDir = initResult.targetPath;
   }
+  log("db path: " + dbDir, 0 /* DEBUG */);
   const timeoutMs = resolveTimeoutMs(options);
   const maxRetries = resolveRetryCount(options);
   try {
@@ -3387,6 +3634,7 @@ function asStringArray2(value) {
   return [];
 }
 async function handleToolCall(client, name, args) {
+  log("tool call: " + name, 0 /* DEBUG */);
   try {
     switch (name) {
       case "search":
@@ -3430,6 +3678,7 @@ async function handleToolCall(client, name, args) {
       case "auto-capture-review":
         return handleAutoCaptureReview();
       default:
+        log("unknown tool: " + name, 2 /* WARNING */);
         return {
           content: [
             {
@@ -3441,6 +3690,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: [
         {
@@ -3815,6 +4068,7 @@ async function handleResourceRead(client, uri) {
       ]
     };
   }
+  log(`Unknown resource URI: ${uri}`, 3 /* ERROR */);
   throw new Error(`Unknown resource URI: ${uri}`);
 }
 
@@ -3891,6 +4145,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;
@@ -3935,6 +4190,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);
@@ -4048,6 +4304,7 @@ function isSamplingResponse(v) {
 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");
@@ -4059,17 +4316,20 @@ async function runAutoCapture(controller, config, client, hostCapabilities, requ
     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,
@@ -4121,6 +4381,7 @@ var AutoCaptureController = class {
    * @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;
@@ -4131,6 +4392,7 @@ var AutoCaptureController = class {
   }
   /** 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;
@@ -4181,10 +4443,12 @@ var McpServer = class {
   }
   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++) {
@@ -4195,6 +4459,10 @@ var McpServer = class {
         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();
       }
     }
@@ -4204,6 +4472,7 @@ var McpServer = class {
       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) => {
@@ -4214,6 +4483,7 @@ var McpServer = class {
           this.autoCaptureController?.reset();
           this.autoCaptureController = null;
           this.client.disconnect();
+          log("MCP stdin closed", 0 /* DEBUG */);
           resolve4();
         });
       });
@@ -4277,6 +4547,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", {
@@ -4323,10 +4594,12 @@ 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);
           }
@@ -4563,6 +4836,7 @@ var McpServer = class {
 
 // src/shared/mcp/functions/create-mcp-server.function.ts
 function createMcpServer(client, contextPath, autoCaptureConfig, clientFactory, maxRetries) {
+  log("creating MCP server", 0 /* DEBUG */);
   return new McpServer(
     client,
     contextPath,
@@ -4584,6 +4858,7 @@ var deps = {
   findDb,
   runInit,
   startMcpServer: async (contextPath, clientFactory, maxRetries) => {
+    log("starting MCP server", 1 /* INFO */);
     const client = await createWorkerClient({
       contextPath,
       workerScript
@@ -4604,7 +4879,9 @@ var deps = {
         clientFactory,
         maxRetries
       );
+      log("MCP server listening on stdio", 0 /* DEBUG */);
       await server.listen();
+      log("MCP server closed", 1 /* INFO */);
     } finally {
       client.disconnect();
     }
@@ -4616,7 +4893,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;
@@ -4624,7 +4901,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.mjs.map