botholomew 0.16.4 → 0.18.0

package/README.md

@@ -14,12 +14,14 @@ documents, researching topics, organizing notes, and maintaining context
 over time — while you sleep, work, or chat with it.
 
 Botholomew has **no shell and no access to your real filesystem**. The
-agent's world is a sandboxed `context/` tree inside the project: it can
-read, write, edit, and grep files there, but cannot escape upward,
-follow symlinks, or touch anything outside. Local files and URLs are
-brought in through `botholomew context add`. External capabilities
-(email, Slack, the web, and hundreds of other services) are granted
-deliberately, per project, through MCP servers wired up via
+agent's world is a per-project knowledge store managed by
+[`membot`](https://github.com/evantahler/membot) — every read, write,
+search, and delete is addressed by `logical_path` (a DB key, not a
+filesystem path), so a prompt-injected attempt to reach `~/.ssh/id_rsa`
+has nowhere to land. Local files and URLs are brought in through
+`botholomew context add`. External capabilities (email, Slack, the web,
+and hundreds of other services) are granted deliberately, per project,
+through MCP servers wired up via
 [MCPX](https://github.com/evantahler/mcpx).
 
 ---
@@ -32,12 +34,13 @@ deliberately, per project, through MCP servers wired up via
 - **Portable.** A project is just a directory of files — markdown for
   prompts, tasks, schedules, and context; CSVs for conversation history.
   Copy it, share it, `git diff` it, check it in (or `.gitignore` it).
-- **Your data, your disk.** Tasks, schedules, threads, and the agent's
-  context tree are all real files you can `vim`, `grep`, and `git`.
-  DuckDB is demoted to a single search-index sidecar (`index.duckdb`)
-  that's fully derivable from disk and safe to delete. Model calls go
-  direct to Anthropic; any further reach is scoped to the MCP servers
-  you add.
+- **Your data, your disk.** Tasks, schedules, threads, prompts, and
+  skills are all real files you can `vim`, `grep`, and `git`. The
+  knowledge store is a single local DuckDB file (`index.duckdb`,
+  managed by [`membot`](https://github.com/evantahler/membot)) — append-only,
+  versioned, queryable with the DuckDB CLI if you ever want to. Model
+  calls go direct to Anthropic; any further reach is scoped to the MCP
+  servers you add.
 - **Extensible.** External tools come from MCP servers via
   [MCPX](https://github.com/evantahler/mcpx) — run them locally (Gmail,
   Slack, GitHub) or connect through an MCP gateway like
@@ -46,9 +49,12 @@ deliberately, per project, through MCP servers wired up via
   Reusable workflows are defined as markdown "skills" (slash commands)
   that the chat agent can also create, edit, and search at runtime.
 - **Safe by default.** The agent has no shell and no direct filesystem
-  access. Every path-taking tool is sandboxed to the project's `context/`
-  tree (NFC normalization + lstat-walk to reject symlinks at any level);
-  every external capability is an MCP server you explicitly add.
+  access. The knowledge store is keyed by `logical_path` (an opaque DB
+  string, not a filesystem path); every external capability is an MCP
+  server you explicitly add. The remaining file-system paths the agent
+  touches (`tasks/`, `schedules/`, `prompts/`, `skills/`) all route
+  through a single sandbox helper (NFC normalization + lstat-walk to
+  reject symlinks at any level).
 - **Concurrent.** Many workers can run at once. Each writes a pidfile
   and heartbeats; tasks and schedules are claimed via `O_EXCL` lockfiles
   and crashed workers get reaped automatically.
@@ -133,8 +139,8 @@ my-project/
     standup.md
     capabilities.md
   mcpx/servers.json                 # external MCP servers (Gmail, Slack, …)
-  models/                           # local embedding model cache
-  context/                          # agent-writable knowledge tree
+  index.duckdb                      # knowledge store (managed by membot)
+  config.json                       # membot config (separate from config/config.json)
   tasks/                            # one markdown file per task
     <id>.md                         #   status & metadata in frontmatter
     .locks/<id>.lock                #   O_EXCL claim file (held by a worker)
@@ -144,12 +150,14 @@ my-project/
   threads/<YYYY-MM-DD>/<id>.csv     # full conversation history
   workers/<id>.json                 # worker pidfile + heartbeat
   logs/<YYYY-MM-DD>/<id>.log        # per-worker logs
-  index.duckdb                      # search index sidecar (rebuildable; safe to delete)
 ```
 
-`index.duckdb` is the only opaque file; everything else is plain text.
-Delete the index any time and `botholomew context reindex` rebuilds it
-from `context/`.
+Tasks, schedules, threads, prompts, and skills are plain text — `vim`,
+`grep`, and `git` work without ceremony. The agent's knowledge store
+lives in `index.duckdb`, managed end-to-end by the
+[`membot`](https://github.com/evantahler/membot) library: ingestion
+(PDF/DOCX/HTML → markdown), local WASM embeddings, hybrid BM25 +
+semantic search, append-only versioning, and URL refresh all live there.
 
 ---
 
@@ -157,8 +165,8 @@ from `context/`.
 
 ![CLI walkthrough: task list, task add, schedule list, context list](docs/assets/cli-tour.gif)
 
-Pulling a remote document straight into `context/` via an LLM-driven
-fetcher (`mcp_search` → `mcp_exec` → save):
+Pulling a remote document straight into the knowledge store via an
+LLM-driven fetcher (`mcp_search` → `mcp_exec` → `membot_pipe`):
 
 ![Importing a Google Doc into context](docs/assets/context-import-gdoc.gif)
 
@@ -170,14 +178,14 @@ fetcher (`mcp_search` → `mcp_exec` → save):
 | `botholomew chat` | Interactive Ink/React TUI |
 | `botholomew task list\|add\|view\|update\|reset\|delete` | Manage the task queue (markdown files in `tasks/`) |
 | `botholomew schedule list\|add\|view\|enable\|disable\|trigger\|delete` | Recurring work (markdown files in `schedules/`) |
-| `botholomew context add\|import\|tree\|stats\|reindex\|search\|read\|write\|edit\|move\|delete\|…` | Bring files/URLs into `context/`; rebuild the search index; expose the agent's file/dir tools as CLI subcommands |
+| `botholomew context add\|ls\|tree\|read\|write\|search\|info\|versions\|diff\|refresh\|…` | Knowledge-store passthrough to [`membot`](https://github.com/evantahler/membot) — `--config` is set to the project dir automatically |
+| `botholomew context import-global` | Seed the project from `~/.membot` (copies `index.duckdb` + `config.json` in) |
 | `botholomew capabilities` | Rescan built-in + MCPX tools and rewrite `prompts/capabilities.md` |
 | `botholomew prompts list\|show\|create\|edit\|delete\|validate` | CRUD over the markdown files in `prompts/` (with strict frontmatter validation) |
 | `botholomew mcpx servers\|list\|add\|remove\|info\|search\|exec\|ping\|auth\|deauth\|import-global\|…` | Configure external MCP servers (passthrough to `mcpx`) |
 | `botholomew skill list\|show\|create\|validate` | Manage slash-command skills |
 | `botholomew thread list\|view` | Browse the agent's conversation history (CSVs in `threads/`) |
-| `botholomew nuke context\|tasks\|schedules\|threads\|all` | Bulk-erase project state |
-| `botholomew db doctor [--repair]` | Probe the search-index DB; rebuild via EXPORT/IMPORT |
+| `botholomew nuke knowledge\|tasks\|schedules\|threads\|all` | Bulk-erase project state |
 | `botholomew upgrade` | Self-update |
 
 All `list` subcommands support `-l, --limit <n>` and `-o, --offset <n>` for pagination.
@@ -206,8 +214,9 @@ All `list` subcommands support `-l, --limit <n>` and `-o, --offset <n>` for pagi
               │       schedules/<id>.md               │
               │       threads/<date>/<id>.csv         │
               │       workers/<id>.json               │
-              │       context/  ─►  index.duckdb      │
-              │                     (search sidecar)  │
+              │       prompts/, skills/, mcpx/        │
+              │       index.duckdb  ◄─ membot         │
+              │       (knowledge store)               │
               └──────────────────┬────────────────────┘
                                  │
                                  ▼
@@ -232,12 +241,11 @@ Topics worth understanding in detail:
 - **[The TUI](docs/tui.md)** — the `botholomew chat` Ink/React terminal UI:
   eight tabs, slash-command autocomplete, message queue, tool-call
   visualization, and a live workers panel.
-- **[Files & the sandbox](docs/files.md)** — the agent's `context/`
-  tree, the path sandbox (NFC + lstat-walk), and how
-  `context_read`/`context_write`/`context_edit` work.
-- **[Context & hybrid search](docs/context-and-search.md)** — LLM-driven
-  chunking, local embeddings, and DuckDB BM25 + linear-scan vector
-  search merged with reciprocal rank fusion.
+- **[Files & the knowledge store](docs/files.md)** — the membot store,
+  the path sandbox (NFC + lstat-walk) for non-knowledge files, and how
+  `membot_read`/`membot_write`/`membot_edit` work.
+- **[Context & search](docs/context-and-search.md)** — pointer to
+  membot for ingestion, chunking, embeddings, and hybrid search.
 - **[Tasks & schedules](docs/tasks-and-schedules.md)** — markdown
   frontmatter as the source of truth, lockfile-based claim, DAG
   validation, and natural-language recurring schedules.
@@ -260,15 +268,12 @@ Topics worth understanding in detail:
 ## Tech stack
 
 - **[Bun](https://bun.sh)** + TypeScript
-- **[DuckDB](https://duckdb.org)** via `@duckdb/node-api` — drives the
-  search-index sidecar only. `array_cosine_distance()` (core DuckDB) for
-  vector search, plus the built-in FTS extension for BM25 keyword
-  search; the index is rebuildable from `context/` at any time
+- **[`membot`](https://github.com/evantahler/membot)** — owns the
+  knowledge store: ingestion (PDF/DOCX/HTML → markdown), local WASM
+  embeddings, hybrid BM25 + semantic search over DuckDB, append-only
+  versioning, URL refresh. Botholomew consumes it as an SDK.
 - **[Anthropic SDK](https://docs.anthropic.com/en/api/client-sdks)** for
   Claude — the reasoning model
-- **[`@huggingface/transformers`](https://huggingface.co/docs/transformers.js)**
-  for local embeddings (default `Xenova/bge-small-en-v1.5`, 384-dim) —
-  no API key, weights cached on first run
 - **[MCPX](https://github.com/evantahler/mcpx)** for external tools
 - **[Ink 6](https://github.com/vadimdemedes/ink)** + **React 19** for the
   terminal UI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.16.4",
+  "version": "0.18.0",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
@@ -28,9 +28,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.92.0",
-    "@duckdb/node-api": "^1.5.2-r.1",
-    "@evantahler/mcpx": "0.21.3",
-    "@huggingface/transformers": "^4.2.0",
+    "@evantahler/mcpx": "0.21.6",
     "ansis": "^4.2.0",
     "commander": "^14.0.0",
     "gray-matter": "^4.0.3",
@@ -38,8 +36,8 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "istextorbinary": "^9.5.0",
+    "membot": "^0.14.0",
     "nanospinner": "^1.2.2",
-    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
     "react": "^19.2.0",
     "uuid": "^14.0.0",
     "wrap-ansi": "^10.0.0",
@@ -57,8 +55,5 @@
   },
   "trustedDependencies": [
     "protobufjs"
-  ],
-  "patchedDependencies": {
-    "@huggingface/transformers@4.2.0": "patches/@huggingface%2Ftransformers@4.2.0.patch"
-  }
+  ]
 }

package/src/chat/agent.ts

@@ -7,8 +7,8 @@ import type {
   ToolUseBlock,
 } from "@anthropic-ai/sdk/resources/messages";
 import type { McpxClient } from "@evantahler/mcpx";
+import type { MembotClient } from "membot";
 import type { BotholomewConfig } from "../config/schemas.ts";
-import { withDb } from "../db/connection.ts";
 import { logInteraction } from "../threads/store.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import {
@@ -24,6 +24,7 @@ import {
   buildMetaHeader,
   extractKeywords,
   loadPersistentContext,
+  MEMBOT_PROMPT_SECTION,
   STYLE_RULES,
 } from "../worker/prompt.ts";
 import type { ChatSession } from "./session.ts";
@@ -35,19 +36,29 @@ import {
 
 registerAllTools();
 
-/** Tools available in chat mode — no worker terminal tools (complete/fail/wait), no bulk-destructive file tools (copy/move, dir ops) */
+/** Tools available in chat mode — no worker terminal tools (complete/fail/wait), and the destructive `membot_prune` is omitted (chat shouldn't permanently GC history). */
 const CHAT_TOOL_NAMES = new Set([
   "create_task",
   "list_tasks",
   "view_task",
   "update_task",
   "delete_task",
-  "context_info",
-  "context_tree",
-  "context_read",
-  "context_write",
-  "context_edit",
-  "search",
+  "membot_add",
+  "membot_list",
+  "membot_tree",
+  "membot_read",
+  "membot_write",
+  "membot_edit",
+  "membot_search",
+  "membot_info",
+  "membot_stats",
+  "membot_versions",
+  "membot_diff",
+  "membot_refresh",
+  "membot_exists",
+  "membot_count_lines",
+  "membot_copy",
+  "membot_pipe",
   "list_threads",
   "view_thread",
   "search_threads",
@@ -62,8 +73,6 @@ const CHAT_TOOL_NAMES = new Set([
   "mcp_search",
   "mcp_info",
   "mcp_exec",
-  "read_large_result",
-  "pipe_to_context",
   "spawn_worker",
   "skill_list",
   "skill_read",
@@ -84,7 +93,6 @@ export async function buildChatSystemPrompt(
   projectDir: string,
   options?: {
     keywordSource?: string;
-    dbPath?: string;
     config?: Required<BotholomewConfig>;
     hasMcpTools?: boolean;
   },
@@ -97,9 +105,9 @@ export async function buildChatSystemPrompt(
   prompt += await loadPersistentContext(projectDir, taskKeywords);
 
   prompt += `## Instructions
-You are Botholomew, an AI agent personified by a wise owl. This is your interactive chat interface. Help the user manage tasks, review results from background worker activity, search context, and answer questions.
+You are Botholomew, an AI agent personified by a wise owl. This is your interactive chat interface. Help the user manage tasks, review results from background worker activity, search the knowledge store, and answer questions.
 You do NOT execute long-running work directly — enqueue tasks for a background worker instead using create_task, and spawn a worker via spawn_worker when the user wants the task run now.
-Use the available tools to look up tasks, threads, schedules, and context when the user asks about them. Files the agent can read and write live under \`context/\` as project-relative paths (e.g. \`notes/foo.md\`). Use \`context_tree\` to see what's there, \`search\` (hybrid regexp + semantic) to find content, then \`context_read\` / \`context_info\` to drill in.
+Use the available tools to look up tasks, threads, schedules, and the knowledge store when the user asks about them. The agent's knowledge lives in the membot store, keyed by \`logical_path\` (e.g. \`notes/foo.md\`). Use \`membot_tree\` to see what's there, \`membot_search\` (hybrid semantic + BM25) to find content, then \`membot_read\` / \`membot_info\` to drill in. Every write creates a new version — use \`membot_versions\` / \`membot_diff\` to inspect history.
 Past conversations live in CSV files under \`threads/\`; use \`list_threads\`, \`search_threads\`, and \`view_thread\` to find and page through them.
 When multiple tool calls are independent of each other (i.e., one does not depend on the result of another), call them all in a single response. They will be executed in parallel, which is faster than calling them one at a time.
 You can manage the agent's prompt files (always-on or keyword-loaded notes the agent sees in every turn) under \`prompts/\` via \`prompt_list\`, \`prompt_read\`, \`prompt_create\`, \`prompt_edit\` (git-style line-range patches), and \`prompt_delete\`. Files marked \`agent-modification: false\` are read-only — \`prompt_edit\` and \`prompt_delete\` will refuse them.
@@ -107,26 +115,28 @@ You can author and refine slash-command skills (reusable prompt templates stored
 Format your responses using Markdown. Use headings, bold, italic, lists, and code blocks to make your responses clear and well-structured.
 `;
 
+  prompt += `\n${MEMBOT_PROMPT_SECTION}`;
+
   if (options?.hasMcpTools) {
     prompt += `
 ## External Tools (MCP)
 
-### Local context first
+### Local knowledge store first
 
-**Before any MCP read, search local context.** Files in \`context/\` (Gmail dumps, GitHub fetches, URL ingests, prior agent outputs) are usually already there — refetching is slower, costs tokens, and risks rate limits.
+**Before any MCP read, search the membot knowledge store.** Prior ingests (Gmail dumps, GitHub fetches, URL captures, prior agent outputs) are usually already there — refetching is slower, costs tokens, and risks rate limits.
 
 Workflow for any "look up / find / read" intent:
 
-1. \`search\` (hybrid regexp + semantic) over \`context/\`, then \`context_read\` / \`context_tree\` to drill in.
-2. If freshness matters, call \`context_info\` and check the file's mtime. To re-pull stale content, write fresh into \`context/\` (\`pipe_to_context\` from an \`mcp_exec\` call is the typical path) rather than going to MCP for the whole document on every question.
+1. \`membot_search\` (hybrid semantic + BM25) over the store, then \`membot_read\` / \`membot_tree\` to drill in.
+2. If freshness matters, call \`membot_info\` and check the source mtime / refresh status. To re-pull stale content, call \`membot_refresh\` for URL-backed entries, or \`membot_pipe\` an \`mcp_exec\` call to capture a fresh snapshot.
 3. Only call \`mcp_exec\` for reads when the data is genuinely missing locally **or** must be real-time (e.g., "what's on my calendar right now").
 
-Writes always go through MCP — sending an email, creating an issue, posting to Slack. Don't search context first for those.
+Writes to external systems always go through MCP — sending an email, creating an issue, posting to Slack. Don't search membot first for those.
 
 Examples:
-- "What does doc X say?" → \`search\` first.
-- "Any new emails from Y?" → \`search\` for the sender under \`context/gmail/\` (or wherever you've been ingesting mail) before hitting Gmail MCP.
-- "Send an email to Y" → MCP write directly; no context lookup.
+- "What does doc X say?" → \`membot_search\` first.
+- "Any new emails from Y?" → \`membot_search\` for the sender's name before hitting Gmail MCP.
+- "Send an email to Y" → MCP write directly; no membot lookup.
 
 ### Calling MCP tools
 
@@ -201,7 +211,7 @@ export async function runChatTurn(input: {
   messages: MessageParam[];
   projectDir: string;
   config: Required<BotholomewConfig>;
-  dbPath: string;
+  mem: MembotClient;
   threadId: string;
   mcpxClient: McpxClient | null;
   callbacks: ChatTurnCallbacks;
@@ -218,7 +228,7 @@ export async function runChatTurn(input: {
     messages,
     projectDir,
     config,
-    dbPath,
+    mem,
     threadId,
     mcpxClient,
     callbacks,
@@ -259,7 +269,6 @@ export async function runChatTurn(input: {
     const keywordSource = findLastUserText(messages);
     const systemPrompt = await buildChatSystemPrompt(projectDir, {
       keywordSource,
-      dbPath,
       config,
       hasMcpTools: mcpxClient != null,
     });
@@ -410,7 +419,7 @@ export async function runChatTurn(input: {
       toolUseBlocks.map(async (toolUse) => {
         const start = Date.now();
         const result = await executeChatToolCall(toolUse, {
-          dbPath,
+          mem,
           projectDir,
           config,
           mcpxClient,
@@ -461,7 +470,7 @@ export async function runChatTurn(input: {
 }
 
 interface ChatToolCallCtx {
-  dbPath: string;
+  mem: MembotClient;
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;
@@ -490,20 +499,8 @@ async function executeChatToolCall(
   }
 
   try {
-    // `sleep` deliberately yields for up to an hour; opening a DuckDB
-    // connection for that whole window would hold the instance-level file
-    // lock and block any worker that also wants the DB. Run it without a
-    // connection — the tool doesn't touch the DB.
-    const runWithoutDb = tool.name === "sleep";
-    const result = runWithoutDb
-      ? await tool.execute(parsed.data, {
-          ...baseCtx,
-          conn: undefined as unknown as ToolContext["conn"],
-        })
-      : await withDb(baseCtx.dbPath, (conn) => {
-          const ctx: ToolContext = { ...baseCtx, conn };
-          return tool.execute(parsed.data, ctx);
-        });
+    const ctx: ToolContext = baseCtx;
+    const result = await tool.execute(parsed.data, ctx);
     const isError =
       typeof result === "object" && result !== null && "is_error" in result
         ? (result as { is_error: boolean }).is_error

package/src/chat/session.ts

@@ -1,11 +1,10 @@
 import type { MessageStream } from "@anthropic-ai/sdk/lib/MessageStream";
 import type { MessageParam } from "@anthropic-ai/sdk/resources/messages";
+import type { MembotClient } from "membot";
 import { loadConfig } from "../config/loader.ts";
 import type { BotholomewConfig } from "../config/schemas.ts";
-import { getDbPath } from "../constants.ts";
-import { withDb } from "../db/connection.ts";
-import { migrate } from "../db/schema.ts";
-import { createMcpxClient } from "../mcpx/client.ts";
+import { createMcpxClient, resolveMcpxDir } from "../mcpx/client.ts";
+import { openMembot, resolveMembotDir } from "../mem/client.ts";
 import { loadSkills } from "../skills/loader.ts";
 import type { SkillDefinition } from "../skills/parser.ts";
 import {
@@ -20,7 +19,7 @@ import { generateThreadTitle } from "../utils/title.ts";
 import { type ChatTurnCallbacks, runChatTurn } from "./agent.ts";
 
 export interface ChatSession {
-  dbPath: string;
+  mem: MembotClient;
   threadId: string;
   projectDir: string;
   config: Required<BotholomewConfig>;
@@ -61,8 +60,8 @@ export async function startChatSession(
     );
   }
 
-  const dbPath = getDbPath(projectDir);
-  await withDb(dbPath, (conn) => migrate(conn));
+  const mem = openMembot(resolveMembotDir(projectDir, config));
+  await mem.connect();
   await ensureThreadsDir(projectDir);
 
   let threadId: string;
@@ -102,15 +101,16 @@ export async function startChatSession(
     );
   }
 
-  const mcpxClient = await createMcpxClient(projectDir);
+  const mcpxClient = await createMcpxClient(resolveMcpxDir(projectDir, config));
   const skills = await loadSkills(projectDir);
 
   const cleanup = async () => {
     await mcpxClient?.close();
+    await mem.close();
   };
 
   return {
-    dbPath,
+    mem,
     threadId,
     projectDir,
     config,
@@ -158,7 +158,7 @@ export async function sendMessage(
     messages: session.messages,
     projectDir: session.projectDir,
     config: session.config,
-    dbPath: session.dbPath,
+    mem: session.mem,
     threadId: session.threadId,
     mcpxClient: session.mcpxClient,
     callbacks,

package/src/cli.ts

@@ -6,7 +6,6 @@ import { registerCapabilitiesCommand } from "./commands/capabilities.ts";
 import { registerChatCommand } from "./commands/chat.ts";
 import { registerCheckUpdateCommand } from "./commands/check-update.ts";
 import { registerContextCommand } from "./commands/context.ts";
-import { registerDbCommand } from "./commands/db.ts";
 import { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
 import { registerNukeCommand } from "./commands/nuke.ts";
@@ -42,7 +41,6 @@ registerThreadCommand(program);
 registerScheduleCommand(program);
 registerChatCommand(program);
 registerContextCommand(program);
-registerDbCommand(program);
 registerCapabilitiesCommand(program);
 registerPromptsCommand(program);
 registerMcpxCommand(program);

package/src/commands/capabilities.ts

@@ -1,9 +1,9 @@
 import type { Command } from "commander";
 import { createSpinner } from "nanospinner";
 import { loadConfig } from "../config/loader.ts";
-import { writeCapabilitiesFile } from "../context/capabilities.ts";
-import { createMcpxClient } from "../mcpx/client.ts";
-import { withDb } from "./with-db.ts";
+import { createMcpxClient, resolveMcpxDir } from "../mcpx/client.ts";
+import { writeCapabilitiesFile } from "../prompts/capabilities.ts";
+import { registerAllTools } from "../tools/registry.ts";
 
 export function registerCapabilitiesCommand(program: Command) {
   program
@@ -12,35 +12,37 @@ export function registerCapabilitiesCommand(program: Command) {
       "Regenerate prompts/capabilities.md by scanning built-in tools and MCPX tools",
     )
     .option("--no-mcp", "Skip MCPX tool enumeration (built-in tools only)")
-    .action((opts: { mcp?: boolean }) =>
-      withDb(program, async (_conn, dir) => {
-        const includeMcp = opts.mcp !== false;
-        const spinner = createSpinner("Loading config").start();
-        const config = await loadConfig(dir);
-        spinner.update({ text: "Connecting to MCPX servers" });
-        const mcpxClient = includeMcp ? await createMcpxClient(dir) : null;
-        try {
-          const result = await writeCapabilitiesFile(
-            dir,
-            mcpxClient,
-            config,
-            (phase) => spinner.update({ text: phase }),
-          );
-          const bits = [
-            `${result.counts.internal} built-in`,
-            `${result.counts.mcp} MCPX`,
-          ];
-          if (!includeMcp) bits.push("MCPX skipped");
-          spinner.success({
-            text: `Wrote ${result.path} (${bits.join(", ")})`,
-          });
-        } catch (err) {
-          spinner.error({ text: `Failed: ${(err as Error).message}` });
-          await mcpxClient?.close();
-          process.exit(1);
-        }
+    .action(async (opts: { mcp?: boolean }) => {
+      const dir = program.opts().dir as string;
+      const includeMcp = opts.mcp !== false;
+      registerAllTools();
+      const spinner = createSpinner("Loading config").start();
+      const config = await loadConfig(dir);
+      spinner.update({ text: "Connecting to MCPX servers" });
+      const mcpxClient = includeMcp
+        ? await createMcpxClient(resolveMcpxDir(dir, config))
+        : null;
+      try {
+        const result = await writeCapabilitiesFile(
+          dir,
+          mcpxClient,
+          config,
+          (phase) => spinner.update({ text: phase }),
+        );
+        const bits = [
+          `${result.counts.internal} built-in`,
+          `${result.counts.mcp} MCPX`,
+        ];
+        if (!includeMcp) bits.push("MCPX skipped");
+        spinner.success({
+          text: `Wrote ${result.path} (${bits.join(", ")})`,
+        });
+      } catch (err) {
+        spinner.error({ text: `Failed: ${(err as Error).message}` });
         await mcpxClient?.close();
-        process.exit(0);
-      }),
-    );
+        process.exit(1);
+      }
+      await mcpxClient?.close();
+      process.exit(0);
+    });
 }