botholomew 0.16.4 → 0.18.0

package/src/commands/context.ts

@@ -1,245 +1,157 @@
-import { stat } from "node:fs/promises";
+import { copyFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
 import { join } from "node:path";
-import ansis from "ansis";
+import { fileURLToPath } from "node:url";
 import type { Command } from "commander";
-import { createSpinner } from "nanospinner";
+import { defaultCliName, OPERATIONS } from "membot";
 import { loadConfig } from "../config/loader.ts";
-import { CONTEXT_DIR, getDbPath } from "../constants.ts";
-import { fetchUrl } from "../context/fetcher.ts";
-import { reindexContext } from "../context/reindex.ts";
-import {
-  buildTree,
-  fileExists,
-  listContextDir,
-  type TreeNode,
-  writeContextFile,
-} from "../context/store.ts";
-import { withDb } from "../db/connection.ts";
-import { indexStats } from "../db/embeddings.ts";
-import { migrate } from "../db/schema.ts";
-import { createMcpxClient } from "../mcpx/client.ts";
-import {
-  type ContextFileMeta,
-  serializeContextFile,
-} from "../utils/frontmatter.ts";
+import { resolveMembotDir } from "../mem/client.ts";
 import { logger } from "../utils/logger.ts";
 
-export function registerContextCommand(program: Command) {
-  const context = program
-    .command("context")
-    .description(
-      "Inspect and manage the on-disk context/ tree (the agent's knowledge store)",
-    );
+const require = createRequire(import.meta.url);
+const ourPkg = require("../../package.json");
+const membotPkg = require("membot/package.json");
 
-  // ---- import --------------------------------------------------------------
-  context
-    .command("import <url>")
-    .description(
-      "Fetch a URL via MCP (Google Docs, Firecrawl, GitHub, etc.) and write the result into context/.",
-    )
-    .option(
-      "-p, --path <path>",
-      "destination path under context/ (default: derived from the URL)",
-    )
-    .option(
-      "--prompt <text>",
-      "extra guidance passed to the LLM-driven fetcher (e.g. 'export as markdown')",
-    )
-    .option("--overwrite", "replace an existing file at the destination path")
-    .action(async (url: string, opts) => {
-      const dir = program.opts().dir;
-      const config = await loadConfig(dir);
-      const mcpxClient = await createMcpxClient(dir);
-      logger.info(`importing ${url}`);
-      try {
-        const fetched = await fetchUrl(url, config, mcpxClient, opts.prompt);
-        const dest = opts.path ?? deriveContextPath(url, fetched.source);
-        const meta: ContextFileMeta = {
-          source_url: url,
-          imported_at: new Date().toISOString(),
-        };
-        // Title falls back to the URL when fetcher couldn't extract one —
-        // skip it in that case to avoid duplicating source_url.
-        if (fetched.title && fetched.title !== url) {
-          meta.title = fetched.title;
-        }
-        const body = serializeContextFile(meta, fetched.content);
-        await writeContextFile(dir, dest, body, {
-          onConflict: opts.overwrite ? "overwrite" : "error",
-        });
-        logger.success(
-          `imported ${body.length} bytes → ${ansis.bold(`context/${dest}`)} (source: ${fetched.source ?? "http"})`,
-        );
+// Soft warning rather than a hard error — membot's SDK API is stable within a
+// minor version, and dev workspaces sometimes pin a newer copy.
+const requested = (ourPkg.dependencies.membot as string).replace(/^[\^~]/, "");
+if (!membotPkg.version.startsWith(requested.split(".")[0])) {
+  logger.warn(
+    `membot version drift: installed ${membotPkg.version}, expected ${ourPkg.dependencies.membot}`,
+  );
+}
 
-        // Reindex so the new file is searchable. reindexContext is
-        // incremental — files whose content_hash matches the index are
-        // skipped, so this only embeds the file we just wrote.
-        const dbPath = getDbPath(dir);
-        await withDb(dbPath, migrate);
-        const summary = await reindexContext(dir, config, dbPath, {
-          onProgress: (msg) => logger.dim(`  ${msg}`),
-        });
-        logger.success(
-          `indexed: ${summary.added} added, ${summary.updated} updated, ${summary.unchanged} unchanged, ${summary.chunksWritten} chunks written`,
-        );
-      } catch (err) {
-        logger.error(
-          `import failed: ${err instanceof Error ? err.message : String(err)}`,
-        );
-        process.exit(1);
-      } finally {
-        await mcpxClient?.close();
-      }
-    });
+const MEMBOT_CLI = fileURLToPath(import.meta.resolve("membot/cli"));
 
-  // ---- reindex -------------------------------------------------------------
-  context
-    .command("reindex")
-    .description(
-      "Walk context/ and reconcile the search index: embed new files, re-embed changed ones, drop rows for removed ones.",
-    )
-    .action(async () => {
-      const dir = program.opts().dir;
-      const config = await loadConfig(dir);
-      const dbPath = getDbPath(dir);
-      // The migrate() call ensures the index DB is initialized, including
-      // the context_index table from migration 19, before we try to write.
-      await withDb(dbPath, migrate);
-      const spinner = createSpinner("reindexing").start();
-      const summary = await reindexContext(dir, config, dbPath, {
-        onProgress: (msg) => spinner.update({ text: msg }),
-      });
-      const parts = [
-        `${summary.added} added`,
-        `${summary.updated} updated`,
-        `${summary.unchanged} unchanged`,
-        `${summary.removed} removed`,
-        `${summary.chunksWritten} chunks written`,
-      ];
-      spinner.success({ text: parts.join(", ") });
-    });
+function getDir(program: Command): string {
+  return program.opts().dir;
+}
 
-  // ---- tree ---------------------------------------------------------------
-  context
-    .command("tree [path]")
-    .description("Render the context/ tree (or a subdirectory).")
+/**
+ * Slice process.argv from the token after "context" so flags (including
+ * --help) and positional args flow through to upstream membot verbatim.
+ */
+function getRawContextArgs(): string[] {
+  const idx = process.argv.indexOf("context");
+  return idx === -1 ? [] : process.argv.slice(idx + 1);
+}
+
+async function runMembot(projectDir: string, args: string[]): Promise<number> {
+  // Resolve membot's data dir from `membot_scope`:
+  //   - "global"  → ~/.membot (default, shared)
+  //   - "project" → <projectDir>
+  // Forward stdio so the user sees the same output they would running
+  // `membot` directly.
+  const config = await loadConfig(projectDir);
+  const membotDir = resolveMembotDir(projectDir, config);
+  const proc = Bun.spawn(["bun", MEMBOT_CLI, "--config", membotDir, ...args], {
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  });
+  return await proc.exited;
+}
+
+/**
+ * Copy the system-wide `~/.membot` data dir into the project, mirroring
+ * `botholomew mcpx import-global`. Useful when the user has built up a
+ * personal knowledge base globally and wants to seed a new project with it.
+ *
+ * Refuses to overwrite a non-empty project membot store unless `--force` is
+ * passed — accidentally clobbering an active project's index is much worse
+ * than re-running the import.
+ */
+function registerImportGlobal(parent: Command, program: Command): void {
+  parent
+    .command("import-global")
+    .description("Copy system-wide membot data (~/.membot) into this project")
     .option(
-      "-d, --max-depth <n>",
-      "max directory depth to render",
-      Number.parseInt,
-      10,
+      "-f, --force",
+      "Overwrite an existing index.duckdb in the project",
+      false,
     )
-    .action(async (path: string | undefined, opts) => {
-      const dir = program.opts().dir;
-      const node = await buildTree(dir, path ?? "", opts.maxDepth);
-      console.log(renderTreeAnsi(node));
-    });
+    .action(async (opts: { force: boolean }) => {
+      const globalDir = join(homedir(), ".membot");
+      if (!existsSync(globalDir)) {
+        logger.error("No global membot data found at ~/.membot");
+        process.exit(1);
+      }
 
-  // ---- stats --------------------------------------------------------------
-  context
-    .command("stats")
-    .description(
-      "Counts and sizes for files under context/ and rows in the search index.",
-    )
-    .action(async () => {
-      const dir = program.opts().dir;
-      const dbPath = getDbPath(dir);
-      const exists = await fileExists(dir, "");
-      if (!exists) {
-        logger.dim(`context/ does not exist under ${dir}`);
-        return;
+      const projectDir = getDir(program);
+      const config = await loadConfig(projectDir);
+      if (config.membot_scope !== "project") {
+        logger.warn(
+          `membot_scope is "${config.membot_scope}" — Botholomew currently reads from ~/.membot. After this import, set membot_scope to "project" in ${getDir(program)}/config/config.json for the project-local copy to take effect.`,
+        );
       }
-      const entries = await listContextDir(dir, "", { recursive: true });
-      let files = 0;
-      let textual = 0;
-      let bytes = 0;
-      for (const e of entries) {
-        if (e.is_directory) continue;
-        files++;
-        if (e.is_textual) textual++;
-        try {
-          const st = await stat(join(dir, CONTEXT_DIR, e.path));
-          bytes += st.size;
-        } catch {
-          // file vanished mid-walk — skip
+      const dest = (name: string) => join(projectDir, name);
+      const destDb = dest("index.duckdb");
+
+      if (existsSync(destDb) && !opts.force) {
+        const stat = statSync(destDb);
+        if (stat.size > 0) {
+          logger.error(
+            `Refusing to overwrite ${destDb} (${stat.size} bytes). Pass --force to replace it.`,
+          );
+          process.exit(1);
         }
       }
-      const idx = await withDb(dbPath, async (conn) => {
-        await migrate(conn);
-        return indexStats(conn);
-      });
-      const rows = [
-        ["files", String(files)],
-        ["textual", String(textual)],
-        ["binary", String(files - textual)],
-        ["bytes on disk", formatBytes(bytes)],
-        ["indexed paths", String(idx.paths)],
-        ["index chunks", String(idx.chunks)],
-        ["embedded chunks", String(idx.embedded)],
-      ];
-      const labelWidth = Math.max(...rows.map((r) => r[0]?.length ?? 0));
-      for (const [label, value] of rows) {
-        console.log(
-          `  ${ansis.dim((label ?? "").padEnd(labelWidth))}  ${value}`,
-        );
+
+      mkdirSync(projectDir, { recursive: true });
+
+      const filesToCopy = ["index.duckdb", "config.json"];
+      let copied = 0;
+      for (const file of filesToCopy) {
+        const src = join(globalDir, file);
+        if (!existsSync(src)) continue;
+        copyFileSync(src, dest(file));
+        logger.success(`Copied ${file}`);
+        copied++;
+      }
+
+      if (copied === 0) {
+        logger.warn("No files found in ~/.membot to copy.");
+        return;
       }
+
+      logger.success(
+        `Imported ${copied} file(s) from ~/.membot into ${projectDir}`,
+      );
     });
 }
 
-/**
- * Pick a sensible default destination under context/ when the user didn't
- * supply --path. Strategy:
- *  - "<source>/<slugified-url>.md" for MCP-served fetches (e.g. google-docs/...)
- *  - "url/<slugified-url>.md" for raw HTTP fallbacks
- */
-function deriveContextPath(url: string, source: string | null): string {
-  const slug = slugifyUrl(url);
-  const root = source ?? "url";
-  return `${root}/${slug}.md`;
-}
+export function registerContextCommand(program: Command) {
+  const context = program
+    .command("context")
+    .description(
+      "Manage the project's knowledge store via membot (add, search, ls, read, …)",
+    );
 
-function slugifyUrl(url: string): string {
-  let parsed: URL;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return url.replace(/[^a-z0-9]+/gi, "-").slice(0, 80);
-  }
-  const path = parsed.pathname.replace(/^\/+|\/+$/g, "").replace(/\//g, "_");
-  const base = path || parsed.hostname;
-  return `${parsed.hostname}_${base}`
-    .replace(/[^a-z0-9._-]+/gi, "-")
-    .replace(/-+/g, "-")
-    .slice(0, 80);
-}
+  // Botholomew-specific helpers first so they show up before the membot
+  // passthrough subcommands in --help.
+  registerImportGlobal(context, program);
 
-function renderTreeAnsi(
-  node: TreeNode,
-  prefix = "",
-  isLast = true,
-  isRoot = true,
-): string {
-  const lines: string[] = [];
-  const connector = isRoot ? "" : isLast ? "└── " : "├── ";
-  const base = node.is_directory
-    ? ansis.blue(node.name === "." ? "context/" : `${node.name}/`)
-    : node.name;
-  const label = node.is_symlink ? `${base} ${ansis.cyan("→")}` : base;
-  lines.push(`${prefix}${connector}${label}`);
-  if (node.is_directory && node.children) {
-    const childPrefix = isRoot ? "" : prefix + (isLast ? "    " : "│   ");
-    const children = node.children;
-    children.forEach((c, i) => {
-      const last = i === children.length - 1;
-      lines.push(renderTreeAnsi(c, childPrefix, last, false));
-    });
+  // One Commander subcommand per membot Operation. We don't redeclare any
+  // flags — Commander hands the raw argv slice to membot, which owns the
+  // canonical schema.
+  for (const op of OPERATIONS) {
+    const name = defaultCliName(op);
+    context
+      .command(name)
+      .description(op.description.split("\n")[0] ?? op.description)
+      .allowUnknownOption(true)
+      .helpOption(false)
+      .argument("[args...]", "arguments forwarded to membot")
+      .action(async () => {
+        const exitCode = await runMembot(getDir(program), getRawContextArgs());
+        if (exitCode !== 0) process.exit(exitCode);
+      });
   }
-  return lines.join("\n");
-}
 
-function formatBytes(n: number): string {
-  if (n === 0) return "0 B";
-  const units = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(n) / Math.log(1024));
-  return `${(n / 1024 ** i).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+  // `botholomew context` (no subcommand) → membot's default action.
+  context.action(async () => {
+    const exitCode = await runMembot(getDir(program), getRawContextArgs());
+    if (exitCode !== 0) process.exit(exitCode);
+  });
 }

package/src/commands/init.ts

@@ -2,6 +2,13 @@ import type { Command } from "commander";
 import { initProject } from "../init/index.ts";
 import { logger } from "../utils/logger.ts";
 
+function parseScope(value: string): "global" | "project" {
+  if (value !== "global" && value !== "project") {
+    throw new Error(`scope must be "global" or "project" (got "${value}")`);
+  }
+  return value;
+}
+
 export function registerInitCommand(program: Command) {
   program
     .command("init")
@@ -10,10 +17,24 @@ export function registerInitCommand(program: Command) {
       "--force",
       "overwrite existing project files; also bypass the unsupported-filesystem check (iCloud/Dropbox/etc)",
     )
+    .option(
+      "--membot-scope <scope>",
+      'where this project reads/writes its knowledge store: "global" (default; shared ~/.membot) or "project" (per-project index.duckdb)',
+      parseScope,
+    )
+    .option(
+      "--mcpx-scope <scope>",
+      'where this project reads its MCPX config: "global" (default; shared ~/.mcpx) or "project" (per-project mcpx/)',
+      parseScope,
+    )
     .action(async (opts) => {
       const dir = program.opts().dir;
       try {
-        await initProject(dir, { force: opts.force });
+        await initProject(dir, {
+          force: opts.force,
+          membotScope: opts.membotScope,
+          mcpxScope: opts.mcpxScope,
+        });
       } catch (err) {
         logger.error(String(err instanceof Error ? err.message : err));
         process.exit(1);

package/src/commands/mcpx.ts

@@ -7,8 +7,8 @@ import type { Command } from "commander";
 import { createSpinner } from "nanospinner";
 import { loadConfig } from "../config/loader.ts";
 import { getMcpxDir } from "../constants.ts";
-import { writeCapabilitiesFile } from "../context/capabilities.ts";
-import { createMcpxClient } from "../mcpx/client.ts";
+import { createMcpxClient, resolveMcpxDir } from "../mcpx/client.ts";
+import { writeCapabilitiesFile } from "../prompts/capabilities.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import { logger } from "../utils/logger.ts";
 
@@ -29,7 +29,11 @@ export async function runMcpx(
   args: (string | undefined)[],
   opts?: { inherit?: boolean },
 ): Promise<string> {
-  const mcpxDir = getMcpxDir(projectDir);
+  // Resolve mcpx config dir from `mcpx_scope`:
+  //   - "global"  → ~/.mcpx (default, shared)
+  //   - "project" → <projectDir>/mcpx
+  const config = await loadConfig(projectDir);
+  const mcpxDir = resolveMcpxDir(projectDir, config);
   const filteredArgs = args.filter((a): a is string => a !== undefined);
   const proc = Bun.spawn(["bun", MCPX_CLI, ...filteredArgs, "-c", mcpxDir], {
     stdout: opts?.inherit ? "inherit" : "pipe",
@@ -124,7 +128,15 @@ export function registerMcpxCommand(program: Command) {
         process.exit(1);
       }
 
-      const projectMcpxDir = getMcpxDir(getDir(program));
+      const projectDir = getDir(program);
+      const cfg = await loadConfig(projectDir);
+      if (cfg.mcpx_scope !== "project") {
+        logger.warn(
+          `mcpx_scope is "${cfg.mcpx_scope}" — Botholomew currently reads from ~/.mcpx. After this import, set mcpx_scope to "project" in ${projectDir}/config/config.json for the project-local copy to take effect.`,
+        );
+      }
+
+      const projectMcpxDir = getMcpxDir(projectDir);
       if (!existsSync(projectMcpxDir)) {
         mkdirSync(projectMcpxDir, { recursive: true });
       }
@@ -149,16 +161,17 @@ export function registerMcpxCommand(program: Command) {
         `Imported ${copied} file(s) from ~/.mcpx into ${projectMcpxDir}`,
       );
 
-      const projectDir = getDir(program);
       registerAllTools();
-      const config = await loadConfig(projectDir);
-      const mcpxClient = await createMcpxClient(projectDir);
+      // After import-global, the freshly-copied files live in the project's
+      // mcpx dir — read them from there so `capabilities.md` reflects what was
+      // just imported, regardless of the user's current `mcpx_scope` setting.
+      const mcpxClient = await createMcpxClient(projectMcpxDir);
       const spinner = createSpinner("Rebuilding capabilities.md").start();
       try {
         const result = await writeCapabilitiesFile(
           projectDir,
           mcpxClient,
-          config,
+          cfg,
           (phase) => spinner.update({ text: phase }),
         );
         spinner.success({

package/src/commands/nuke.ts

@@ -1,20 +1,17 @@
 import { rm } from "node:fs/promises";
+import { join } from "node:path";
 import ansis from "ansis";
 import type { Command } from "commander";
-import {
-  CONTEXT_DIR,
-  getContextDir,
-  SCHEDULES_DIR,
-  TASKS_DIR,
-  THREADS_DIR,
-} from "../constants.ts";
+import { loadConfig } from "../config/loader.ts";
+import { SCHEDULES_DIR, TASKS_DIR, THREADS_DIR } from "../constants.ts";
+import { openMembot, resolveMembotDir } from "../mem/client.ts";
 import { deleteAllSchedules } from "../schedules/store.ts";
 import { deleteAllTasks } from "../tasks/store.ts";
 import { deleteAllThreads } from "../threads/store.ts";
 import { logger } from "../utils/logger.ts";
 import { listWorkers } from "../workers/store.ts";
 
-type NukeScope = "context" | "tasks" | "schedules" | "threads" | "all";
+type NukeScope = "knowledge" | "tasks" | "schedules" | "threads" | "all";
 
 async function ensureNoRunningWorkers(projectDir: string): Promise<boolean> {
   const running = await listWorkers(projectDir, { status: "running" });
@@ -30,10 +27,50 @@ async function ensureNoRunningWorkers(projectDir: string): Promise<boolean> {
   return true;
 }
 
+/**
+ * Erase the membot knowledge store: tombstone every current file and prune
+ * non-current versions. We do this through the SDK rather than `rm`ing
+ * `index.duckdb` directly so a concurrent open client (e.g. a tool call in
+ * mid-flight) doesn't lose data unpredictably; if the file is empty / missing
+ * we fall back to deleting it outright.
+ */
+async function nukeKnowledge(projectDir: string): Promise<void> {
+  const config = await loadConfig(projectDir);
+  const membotDir = resolveMembotDir(projectDir, config);
+  const indexPath = join(membotDir, "index.duckdb");
+  if (config.membot_scope !== "project") {
+    logger.warn(
+      `membot_scope is "${config.membot_scope}"; this will erase the SHARED knowledge store at ${membotDir}`,
+    );
+  }
+  try {
+    const mem = openMembot(membotDir);
+    try {
+      const list = await mem.list({ limit: 100_000 });
+      const paths = list.entries.map((e) => e.logical_path);
+      if (paths.length > 0) {
+        await mem.remove({ paths });
+      }
+      // Drop all versions older than now (i.e. everything we just tombstoned).
+      await mem.prune({ before: new Date().toISOString() });
+      logger.success(
+        `Cleared the membot knowledge store (${paths.length} entries removed, history pruned)`,
+      );
+    } finally {
+      await mem.close();
+    }
+  } catch (err) {
+    logger.warn(
+      `membot prune failed (${(err as Error).message}); removing ${indexPath} instead`,
+    );
+    await rm(indexPath, { force: true });
+    logger.success(`Removed ${indexPath}`);
+  }
+}
+
 async function runNuke(projectDir: string, scope: NukeScope): Promise<void> {
-  if (scope === "context" || scope === "all") {
-    await rm(getContextDir(projectDir), { recursive: true, force: true });
-    logger.success(`Removed ${CONTEXT_DIR}/ directory`);
+  if (scope === "knowledge" || scope === "all") {
+    await nukeKnowledge(projectDir);
   }
   if (scope === "tasks" || scope === "all") {
     const n = await deleteAllTasks(projectDir);
@@ -71,7 +108,7 @@ function registerScope(
         console.log(ansis.red.bold(`Nuke scope: ${scope}`));
         console.log(
           ansis.yellow(
-            `Re-run with --yes to confirm. This will delete files on disk; cannot be undone.`,
+            `Re-run with --yes to confirm. This will delete data; cannot be undone.`,
           ),
         );
         process.exit(1);
@@ -89,8 +126,8 @@ export function registerNukeCommand(program: Command) {
   registerScope(
     program,
     nuke,
-    "context",
-    `Erase the entire ${CONTEXT_DIR}/ directory (user-curated knowledge)`,
+    "knowledge",
+    "Erase the entire membot knowledge store (every current entry tombstoned and pruned)",
   );
   registerScope(
     program,
@@ -114,6 +151,6 @@ export function registerNukeCommand(program: Command) {
     program,
     nuke,
     "all",
-    "Erase all agent-writable data: context/, tasks/, schedules/, threads/",
+    "Erase all agent-writable data: membot store, tasks/, schedules/, threads/",
   );
 }

package/src/commands/prepare.ts

@@ -1,21 +1,24 @@
 import type { Command } from "commander";
 import { loadConfig } from "../config/loader.ts";
-import { embedSingle } from "../context/embedder.ts";
+import { openMembot, resolveMembotDir } from "../mem/client.ts";
 import { logger } from "../utils/logger.ts";
-import { withDb } from "./with-db.ts";
 
 export function registerPrepareCommand(program: Command) {
   program
     .command("prepare")
-    .description("Verify API keys and connectivity. Run this on first setup.")
-    .action(() =>
-      withDb(program, async (_conn, dir) => {
-        logger.info("Preparing Botholomew...");
-        const config = await loadConfig(dir);
-        await embedSingle("test", config);
-        logger.success(
-          `Embedding model ${config.embedding_model} is loaded and ready.`,
-        );
-      }),
-    );
+    .description(
+      "Verify the project is healthy: load config and open the membot knowledge store (triggers any first-run migration / model download).",
+    )
+    .action(async () => {
+      const projectDir = program.opts().dir as string;
+      logger.info("Preparing Botholomew...");
+      const config = await loadConfig(projectDir);
+      const mem = openMembot(resolveMembotDir(projectDir, config));
+      try {
+        await mem.connect();
+        logger.success("membot knowledge store opened successfully");
+      } finally {
+        await mem.close();
+      }
+    });
 }

package/src/config/loader.ts

@@ -1,5 +1,4 @@
-import { mkdirSync } from "node:fs";
-import { getConfigPath, getModelsDir } from "../constants.ts";
+import { getConfigPath } from "../constants.ts";
 import { setLogLevel } from "../utils/logger.ts";
 import { type BotholomewConfig, DEFAULT_CONFIG } from "./schemas.ts";
 
@@ -23,12 +22,6 @@ export async function loadConfig(
 
   setLogLevel(config.log_level);
 
-  const modelsDir = getModelsDir(projectDir);
-  mkdirSync(modelsDir, { recursive: true });
-  // Dynamic import keeps @huggingface/transformers (heavy, pulls ONNX runtime) out of commands that never embed.
-  const { setEmbeddingCacheDir } = await import("../context/embedder-impl.ts");
-  setEmbeddingCacheDir(modelsDir);
-
   return config;
 }