botholomew 0.18.1 → 0.18.3

package/README.md

@@ -19,7 +19,7 @@ agent's world is a per-project knowledge store managed by
 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,
+`botholomew membot 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).
@@ -165,11 +165,6 @@ semantic search, append-only versioning, and URL refresh all live there.
 
 ![CLI walkthrough: task list, task add, schedule list, context list](docs/assets/cli-tour.gif)
 
-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)
-
 | Command | Purpose |
 |---|---|
 | `botholomew init` | Initialize the current directory as a project (refuses on iCloud/Dropbox/NFS without `--force`) |
@@ -178,8 +173,8 @@ LLM-driven fetcher (`mcp_search` → `mcp_exec` → `membot_pipe`):
 | `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\|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 membot add\|ls\|tree\|read\|write\|search\|info\|versions\|diff\|refresh\|…` | Knowledge-store passthrough to [`membot`](https://github.com/evantahler/membot) — `--config` is resolved from `membot_scope` (default `~/.membot`) |
+| `botholomew membot 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`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.18.1",
+  "version": "0.18.3",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
@@ -27,31 +27,31 @@
     "docs:preview": "vitepress preview docs"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.92.0",
-    "@evantahler/mcpx": "0.21.6",
-    "ansis": "^4.2.0",
+    "@anthropic-ai/sdk": "^0.95.2",
+    "@evantahler/mcpx": "0.21.7",
+    "ansis": "^4.3.0",
     "commander": "^14.0.0",
     "gray-matter": "^4.0.3",
     "ink": "^7.0.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "istextorbinary": "^9.5.0",
-    "membot": "^0.14.0",
+    "membot": "^0.15.0",
     "nanospinner": "^1.2.2",
-    "react": "^19.2.0",
+    "react": "^19.2.6",
     "uuid": "^14.0.0",
     "wrap-ansi": "^10.0.0",
-    "zod": "^4.4.2"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.14",
+    "@biomejs/biome": "^2.4.15",
     "@types/bun": "latest",
     "@types/react": "^19.2.0",
     "@types/uuid": "^11.0.0",
     "typescript": "^6.0.3",
     "vitepress": "^1.5.0",
-    "vitepress-plugin-llms": "^1.12.1",
-    "vue": "^3.5.0"
+    "vitepress-plugin-llms": "^1.12.2",
+    "vue": "^3.5.34"
   },
   "trustedDependencies": [
     "protobufjs"

package/src/chat/agent.ts

@@ -7,8 +7,13 @@ 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 {
+  openMembot,
+  resolveMembotDir,
+  sharedWithMem,
+  type WithMem,
+} from "../mem/client.ts";
 import { logInteraction } from "../threads/store.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import {
@@ -211,7 +216,6 @@ export async function runChatTurn(input: {
   messages: MessageParam[];
   projectDir: string;
   config: Required<BotholomewConfig>;
-  mem: MembotClient;
   threadId: string;
   mcpxClient: McpxClient | null;
   callbacks: ChatTurnCallbacks;
@@ -223,12 +227,43 @@ export async function runChatTurn(input: {
    *  Production callers should leave both unset. */
   _testClient?: Anthropic;
   _testMaxInputTokens?: number;
+  /** Test seam: when set, the turn uses this `withMem` instead of opening its
+   *  own membot client. Production callers leave this unset. */
+  _testWithMem?: WithMem;
+}): Promise<void> {
+  // Open membot for the duration of this turn so the DuckDB file lock is held
+  // only while the turn is actively executing — idle chat sessions leave the
+  // shared `~/.membot` store available to other Botholomew processes.
+  if (input._testWithMem) {
+    await runChatTurnBody({ ...input, withMem: input._testWithMem });
+    return;
+  }
+  const mem = openMembot(resolveMembotDir(input.projectDir, input.config));
+  await mem.connect();
+  try {
+    await runChatTurnBody({ ...input, withMem: sharedWithMem(mem) });
+  } finally {
+    await mem.close();
+  }
+}
+
+async function runChatTurnBody(input: {
+  messages: MessageParam[];
+  projectDir: string;
+  config: Required<BotholomewConfig>;
+  withMem: WithMem;
+  threadId: string;
+  mcpxClient: McpxClient | null;
+  callbacks: ChatTurnCallbacks;
+  session?: ChatSession;
+  _testClient?: Anthropic;
+  _testMaxInputTokens?: number;
 }): Promise<void> {
   const {
     messages,
     projectDir,
     config,
-    mem,
+    withMem,
     threadId,
     mcpxClient,
     callbacks,
@@ -419,7 +454,7 @@ export async function runChatTurn(input: {
       toolUseBlocks.map(async (toolUse) => {
         const start = Date.now();
         const result = await executeChatToolCall(toolUse, {
-          mem,
+          withMem,
           projectDir,
           config,
           mcpxClient,
@@ -470,7 +505,7 @@ export async function runChatTurn(input: {
 }
 
 interface ChatToolCallCtx {
-  mem: MembotClient;
+  withMem: WithMem;
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;

package/src/chat/session.ts

@@ -1,10 +1,8 @@
 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 { 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 {
@@ -19,7 +17,6 @@ import { generateThreadTitle } from "../utils/title.ts";
 import { type ChatTurnCallbacks, runChatTurn } from "./agent.ts";
 
 export interface ChatSession {
-  mem: MembotClient;
   threadId: string;
   projectDir: string;
   config: Required<BotholomewConfig>;
@@ -60,8 +57,6 @@ export async function startChatSession(
     );
   }
 
-  const mem = openMembot(resolveMembotDir(projectDir, config));
-  await mem.connect();
   await ensureThreadsDir(projectDir);
 
   let threadId: string;
@@ -106,11 +101,9 @@ export async function startChatSession(
 
   const cleanup = async () => {
     await mcpxClient?.close();
-    await mem.close();
   };
 
   return {
-    mem,
     threadId,
     projectDir,
     config,
@@ -158,7 +151,6 @@ export async function sendMessage(
     messages: session.messages,
     projectDir: session.projectDir,
     config: session.config,
-    mem: session.mem,
     threadId: session.threadId,
     mcpxClient: session.mcpxClient,
     callbacks,

package/src/cli.ts

@@ -5,9 +5,9 @@ import { program } from "commander";
 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 { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
+import { registerMembotCommand } from "./commands/membot.ts";
 import { registerNukeCommand } from "./commands/nuke.ts";
 import { registerPrepareCommand } from "./commands/prepare.ts";
 import { registerPromptsCommand } from "./commands/prompts.ts";
@@ -44,7 +44,7 @@ registerTaskCommand(program);
 registerThreadCommand(program);
 registerScheduleCommand(program);
 registerChatCommand(program);
-registerContextCommand(program);
+registerMembotCommand(program);
 registerCapabilitiesCommand(program);
 registerPromptsCommand(program);
 registerMcpxCommand(program);

package/src/commands/{context.ts → membot.ts}

@@ -29,11 +29,11 @@ function getDir(program: Command): string {
 }
 
 /**
- * Slice process.argv from the token after "context" so flags (including
+ * Slice process.argv from the token after "membot" so flags (including
  * --help) and positional args flow through to upstream membot verbatim.
  */
-function getRawContextArgs(): string[] {
-  const idx = process.argv.indexOf("context");
+function getRawMembotArgs(): string[] {
+  const idx = process.argv.indexOf("membot");
   return idx === -1 ? [] : process.argv.slice(idx + 1);
 }
 
@@ -121,37 +121,37 @@ function registerImportGlobal(parent: Command, program: Command): void {
     });
 }
 
-export function registerContextCommand(program: Command) {
-  const context = program
-    .command("context")
+export function registerMembotCommand(program: Command) {
+  const membot = program
+    .command("membot")
     .description(
-      "Manage the project's knowledge store via membot (add, search, ls, read, …)",
+      "Manage the project's knowledge store (passthrough to membot: add, search, ls, read, …)",
     );
 
   // Botholomew-specific helpers first so they show up before the membot
   // passthrough subcommands in --help.
-  registerImportGlobal(context, program);
+  registerImportGlobal(membot, program);
 
   // 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
+    membot
       .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());
+        const exitCode = await runMembot(getDir(program), getRawMembotArgs());
         if (exitCode !== 0) process.exit(exitCode);
       });
   }
 
-  // `botholomew context` (no subcommand) → membot's default action.
-  context.action(async () => {
-    const exitCode = await runMembot(getDir(program), getRawContextArgs());
+  // `botholomew membot` (no subcommand) → membot's default action.
+  membot.action(async () => {
+    const exitCode = await runMembot(getDir(program), getRawMembotArgs());
     if (exitCode !== 0) process.exit(exitCode);
   });
 }

package/src/mem/client.ts

@@ -31,3 +31,52 @@ export function resolveMembotDir(
 export function openMembot(dataDir: string): MembotClient {
   return new MembotClient({ configFlag: dataDir });
 }
+
+/**
+ * A scope-bound membot accessor passed via `ToolContext.withMem`. Each call
+ * runs `fn` with a live `MembotClient` and is responsible for whatever
+ * open/close lifecycle is appropriate for the surrounding scope.
+ */
+export type WithMem = <T>(fn: (mem: MembotClient) => Promise<T>) => Promise<T>;
+
+/**
+ * Build a `WithMem` that forwards to an already-open client, **serializing**
+ * concurrent callers through a per-client queue. Used inside a chat turn or
+ * worker tick that opens membot once and shares it across all tool calls
+ * within that scope.
+ *
+ * Why serialize: every `MembotClient.<op>` releases the underlying DuckDB
+ * instance in `finally` (so other processes can grab the file lock). When
+ * two ops run on the same client in parallel via `Promise.all`, the first to
+ * finish closes the connection out from under the slower one, and the slower
+ * op's next query hangs on a disposed handle. Queuing here keeps the "many
+ * parallel tool calls in one chat turn" pattern correct without forcing
+ * unrelated (non-membot) tool calls to serialize.
+ */
+export function sharedWithMem(mem: MembotClient): WithMem {
+  let queue: Promise<unknown> = Promise.resolve();
+  return <T>(fn: (m: MembotClient) => Promise<T>): Promise<T> => {
+    const result = queue.then(() => fn(mem));
+    // One failed op shouldn't poison the rest of the queue.
+    queue = result.catch(() => {});
+    return result as Promise<T>;
+  };
+}
+
+/**
+ * Build a `WithMem` that opens a fresh `MembotClient` per call, runs `fn`,
+ * and closes it in `finally`. Used in sparse, user-triggered contexts (e.g.
+ * the TUI ContextPanel) where holding the DuckDB file lock between ops would
+ * block other Botholomew processes from the shared `~/.membot` store.
+ */
+export function scopedWithMem(dataDir: string): WithMem {
+  return async (fn) => {
+    const mem = openMembot(dataDir);
+    try {
+      await mem.connect();
+      return await fn(mem);
+    } finally {
+      await mem.close();
+    }
+  };
+}

package/src/tools/membot/adapter.ts

@@ -86,8 +86,10 @@ export function adaptOperation(
     outputSchema: membotOutputSchema,
     execute: async (input, ctx: ToolContext) => {
       try {
-        const method = ctx.mem[methodName] as (i: unknown) => Promise<unknown>;
-        const data = await method.call(ctx.mem, input);
+        const data = await ctx.withMem(async (mem) => {
+          const method = mem[methodName] as (i: unknown) => Promise<unknown>;
+          return method.call(mem, input);
+        });
         return { is_error: false, data };
       } catch (err) {
         if (isHelpfulError(err)) {
@@ -103,7 +105,7 @@ export function adaptOperation(
           error_type: "internal_error",
           message: err instanceof Error ? err.message : String(err),
           next_action_hint:
-            "Check the project's membot store (run `botholomew context stats`) and try again. If this persists, file a bug.",
+            "Check the project's membot store (run `botholomew membot stats`) and try again. If this persists, file a bug.",
         };
       }
     },

package/src/tools/membot/copy.ts

@@ -27,12 +27,14 @@ export const membotCopyTool = {
   outputSchema,
   execute: async (input, ctx) => {
     try {
-      const src = await ctx.mem.read({ logical_path: input.from_logical_path });
-      const written = await ctx.mem.write({
-        logical_path: input.to_logical_path,
-        content: src.content ?? "",
-        change_note:
-          input.change_note ?? `copied from ${input.from_logical_path}`,
+      const written = await ctx.withMem(async (mem) => {
+        const src = await mem.read({ logical_path: input.from_logical_path });
+        return mem.write({
+          logical_path: input.to_logical_path,
+          content: src.content ?? "",
+          change_note:
+            input.change_note ?? `copied from ${input.from_logical_path}`,
+        });
       });
       return {
         is_error: false,

package/src/tools/membot/count_lines.ts

@@ -25,7 +25,9 @@ export const membotCountLinesTool = {
   outputSchema,
   execute: async (input, ctx) => {
     try {
-      const result = await ctx.mem.read({ logical_path: input.logical_path });
+      const result = await ctx.withMem((mem) =>
+        mem.read({ logical_path: input.logical_path }),
+      );
       const content = result.content ?? "";
       const lineCount = content === "" ? 0 : content.split("\n").length;
       return {

package/src/tools/membot/edit.ts

@@ -38,12 +38,14 @@ export const membotEditTool = {
   outputSchema,
   execute: async (input, ctx) => {
     try {
-      const current = await ctx.mem.read({ logical_path: input.logical_path });
-      const next = applyLinePatches(current.content ?? "", input.patches);
-      const result = await ctx.mem.write({
-        logical_path: input.logical_path,
-        content: next,
-        change_note: input.change_note,
+      const result = await ctx.withMem(async (mem) => {
+        const current = await mem.read({ logical_path: input.logical_path });
+        const next = applyLinePatches(current.content ?? "", input.patches);
+        return mem.write({
+          logical_path: input.logical_path,
+          content: next,
+          change_note: input.change_note,
+        });
       });
       return {
         is_error: false,

package/src/tools/membot/exists.ts

@@ -23,7 +23,9 @@ export const membotExistsTool = {
   outputSchema,
   execute: async (input, ctx) => {
     try {
-      await ctx.mem.info({ logical_path: input.logical_path });
+      await ctx.withMem((mem) =>
+        mem.info({ logical_path: input.logical_path }),
+      );
       return {
         is_error: false,
         exists: true,

package/src/tools/membot/pipe.ts

@@ -143,11 +143,13 @@ export const membotPipeTool = {
     }
 
     try {
-      const written = await ctx.mem.write({
-        logical_path: input.logical_path,
-        content: innerOutput,
-        change_note: input.change_note,
-      });
+      const written = await ctx.withMem((mem) =>
+        mem.write({
+          logical_path: input.logical_path,
+          content: innerOutput,
+          change_note: input.change_note,
+        }),
+      );
       return {
         is_error: false,
         logical_path: written.logical_path,

package/src/tools/tool.ts

@@ -1,17 +1,18 @@
 import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import type { McpxClient } from "@evantahler/mcpx";
-import type { MembotClient } from "membot";
 import { z } from "zod";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import type { WithMem } from "../mem/client.ts";
 
 export interface ToolContext {
   /**
-   * Per-process membot client. Backs every `membot_*` tool. Membot manages
-   * its own DuckDB connection lifecycle internally (lazy claim, release
-   * between operations), so tools just call `ctx.mem.<op>(...)` directly —
-   * no per-call open/close needed.
+   * Scope-bound membot accessor. Each `membot_*` tool wraps its work in
+   * `ctx.withMem((mem) => mem.<op>(...))`. Backed by `sharedWithMem` inside a
+   * chat turn / worker tick (one connection, many ops) or `scopedWithMem` in
+   * sparse callers like the TUI panel (open per op, release the DuckDB file
+   * lock between calls).
    */
-  mem: MembotClient;
+  withMem: WithMem;
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;

package/src/tui/components/ContextPanel.tsx

@@ -1,7 +1,7 @@
 import { Box, Text, useInput } from "ink";
-import type { MembotClient } from "membot";
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
-import { openMembot } from "../../mem/client.ts";
+import { loadConfig } from "../../config/loader.ts";
+import { resolveMembotDir, scopedWithMem } from "../../mem/client.ts";
 import {
   detailPaneBorderProps,
   type FocusState,
@@ -36,8 +36,8 @@ const PAGE_SCROLL_LINES = 10;
  * Browse the membot knowledge store. Each row is a current-version entry; the
  * detail pane shows the cleaned markdown surrogate. Membot has no real
  * directories — `logical_path` segments are just slashes — so this is a flat
- * paginated list rather than a tree drill-in. Use `botholomew context tree` /
- * `botholomew context search` for hierarchical or content-based discovery.
+ * paginated list rather than a tree drill-in. Use `botholomew membot tree` /
+ * `botholomew membot search` for hierarchical or content-based discovery.
  */
 export const ContextPanel = memo(function ContextPanel({
   projectDir,
@@ -46,16 +46,26 @@ export const ContextPanel = memo(function ContextPanel({
   const { rows: termRows, cols: termCols } = useTerminalSize();
   const detailWidth = Math.max(1, termCols - SIDEBAR_WIDTH - 5);
 
-  // One MembotClient per panel mount. Membot manages its DB lock per-op so
-  // sharing the file with the chat session / workers is safe.
-  const [client, setClient] = useState<MembotClient | null>(null);
+  // Open a fresh membot client per op (list/read/delete) instead of holding
+  // one for the panel's lifetime. Holding the DuckDB file lock for the panel
+  // mount would block other Botholomew processes (workers, chat turns, the
+  // membot CLI) from the shared `~/.membot` store while this panel sits idle.
+  const [membotDir, setMembotDir] = useState<string | null>(null);
   useEffect(() => {
-    const c = openMembot(projectDir);
-    setClient(c);
+    let cancelled = false;
+    (async () => {
+      const config = await loadConfig(projectDir);
+      if (cancelled) return;
+      setMembotDir(resolveMembotDir(projectDir, config));
+    })();
     return () => {
-      void c.close();
+      cancelled = true;
     };
   }, [projectDir]);
+  const withMem = useMemo(
+    () => (membotDir ? scopedWithMem(membotDir) : null),
+    [membotDir],
+  );
 
   const [entries, setEntries] = useState<ContextEntry[]>([]);
   const [selectedIndex, setSelectedIndex] = useState(0);
@@ -70,9 +80,9 @@ export const ContextPanel = memo(function ContextPanel({
   const visibleRows = Math.max(1, termRows - 6);
 
   const refresh = useCallback(async () => {
-    if (!client) return;
+    if (!withMem) return;
     try {
-      const out = await client.list({ limit: 500 });
+      const out = await withMem((mem) => mem.list({ limit: 500 }));
       const list = out.entries.map((e) => ({
         logical_path: e.logical_path,
         version_id: e.version_id,
@@ -89,7 +99,7 @@ export const ContextPanel = memo(function ContextPanel({
       setSelectedIndex(0);
       setSidebarScrollOffset(0);
     }
-  }, [client]);
+  }, [withMem]);
 
   useEffect(() => {
     refresh();
@@ -107,14 +117,13 @@ export const ContextPanel = memo(function ContextPanel({
 
   useEffect(() => {
     let cancelled = false;
-    if (!selectedEntry || !client) {
+    if (!selectedEntry || !withMem) {
       setFileContent(null);
       setDetailScroll(0);
       return;
     }
     setDetailScroll(0);
-    client
-      .read({ logical_path: selectedEntry.logical_path })
+    withMem((mem) => mem.read({ logical_path: selectedEntry.logical_path }))
       .then((result) => {
         if (cancelled) return;
         setFileContent({
@@ -132,7 +141,7 @@ export const ContextPanel = memo(function ContextPanel({
     return () => {
       cancelled = true;
     };
-  }, [client, selectedEntry]);
+  }, [withMem, selectedEntry]);
 
   const detailLines = useMemo(() => {
     if (!fileContent || !selectedEntry) return [];
@@ -157,11 +166,11 @@ export const ContextPanel = memo(function ContextPanel({
 
   const deleteConfirm = useDeleteConfirm(() => {
     const entry = selectedEntryRef.current;
-    if (!entry || !client) return;
+    if (!entry || !withMem) return;
     const path = entry.logical_path;
     (async () => {
       try {
-        await client.remove({ paths: [path] });
+        await withMem((mem) => mem.remove({ paths: [path] }));
       } catch {
         // ignore — refresh will reflect any partial state
       }
@@ -227,7 +236,7 @@ export const ContextPanel = memo(function ContextPanel({
         </Box>
         {entries.length === 0 ? (
           <Box paddingX={1}>
-            <Text dimColor>(empty — try `botholomew context add …`)</Text>
+            <Text dimColor>(empty — try `botholomew membot add …`)</Text>
           </Box>
         ) : (
           visibleItems.map((entry, vi) => {

package/src/worker/index.ts

@@ -2,7 +2,6 @@ import { hostname } from "node:os";
 import ansis from "ansis";
 import { loadConfig } from "../config/loader.ts";
 import { createMcpxClient, resolveMcpxDir } from "../mcpx/client.ts";
-import { openMembot, resolveMembotDir } from "../mem/client.ts";
 import { logger } from "../utils/logger.ts";
 import { uuidv7 } from "../utils/uuid.ts";
 import { markWorkerStopped, registerWorker } from "../workers/store.ts";
@@ -87,10 +86,6 @@ export async function startWorker(
   const evalSchedules = options.evalSchedules ?? !taskId;
 
   const config = await loadConfig(projectDir);
-  const mem = openMembot(resolveMembotDir(projectDir, config));
-  // Surface init-time failures (bad config, locked DB) up front rather than
-  // letting the first tool call do it.
-  await mem.connect();
 
   const mcpxClient = await createMcpxClient(resolveMcpxDir(projectDir, config));
   if (mcpxClient) {
@@ -127,7 +122,6 @@ export async function startWorker(
     stopHeartbeat();
     stopReaper();
     await mcpxClient?.close();
-    await mem.close();
     try {
       await markWorkerStopped(projectDir, workerId);
     } catch (err) {
@@ -150,7 +144,6 @@ export async function startWorker(
       if (taskId) {
         await runSpecificTask({
           projectDir,
-          mem,
           config,
           workerId,
           taskId,
@@ -160,7 +153,6 @@ export async function startWorker(
       } else {
         await tick({
           projectDir,
-          mem,
           config,
           workerId,
           mcpxClient,
@@ -181,7 +173,6 @@ export async function startWorker(
       try {
         didWork = await tick({
           projectDir,
-          mem,
           config,
           workerId,
           mcpxClient,
@@ -207,6 +198,5 @@ export async function startWorker(
       logger.warn(`failed to mark worker stopped: ${err}`);
     }
     await mcpxClient?.close();
-    await mem.close();
   }
 }

package/src/worker/llm.ts

@@ -5,8 +5,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 type { WithMem } from "../mem/client.ts";
 import type { Task } from "../tasks/schema.ts";
 import { getTask } from "../tasks/store.ts";
 import { logInteraction } from "../threads/store.ts";
@@ -50,7 +50,7 @@ export async function runAgentLoop(input: {
   systemPrompt: string;
   task: Task;
   config: Required<BotholomewConfig>;
-  mem: MembotClient;
+  withMem: WithMem;
   threadId: string;
   projectDir: string;
   workerId?: string;
@@ -61,7 +61,7 @@ export async function runAgentLoop(input: {
     systemPrompt,
     task,
     config,
-    mem,
+    withMem,
     threadId,
     projectDir,
     workerId,
@@ -205,7 +205,7 @@ export async function runAgentLoop(input: {
       toolUseBlocks.map(async (toolUse) => {
         const start = Date.now();
         const result = await executeToolCall(toolUse, {
-          mem,
+          withMem,
           projectDir,
           config,
           mcpxClient: input.mcpxClient ?? null,
@@ -264,7 +264,7 @@ interface ToolCallResult {
 }
 
 interface ToolCallCtx {
-  mem: MembotClient;
+  withMem: WithMem;
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;

package/src/worker/tick.ts

@@ -1,6 +1,11 @@
 import type { McpxClient } from "@evantahler/mcpx";
-import type { MembotClient } from "membot";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import {
+  openMembot,
+  resolveMembotDir,
+  sharedWithMem,
+  type WithMem,
+} from "../mem/client.ts";
 import type { Task } from "../tasks/schema.ts";
 import {
   claimNextTask,
@@ -19,7 +24,6 @@ import { processSchedules } from "./schedules.ts";
 
 export interface TickOptions {
   projectDir: string;
-  mem: MembotClient;
   config: Required<BotholomewConfig>;
   workerId: string;
   mcpxClient?: McpxClient | null;
@@ -31,11 +35,15 @@ export interface TickOptions {
 /**
  * Run one unit of work for a worker: optionally evaluate schedules, claim
  * the next eligible task, and process it. Returns true if work was done.
+ *
+ * Opens a membot client for the duration of this tick and closes it on the
+ * way out so the DuckDB file lock is released between ticks — other
+ * Botholomew processes (other workers, chat, the membot CLI) can read the
+ * shared `~/.membot` store while this worker is idle.
  */
 export async function tick(opts: TickOptions): Promise<boolean> {
   const {
     projectDir,
-    mem,
     config,
     workerId,
     mcpxClient,
@@ -74,15 +82,21 @@ export async function tick(opts: TickOptions): Promise<boolean> {
     return false;
   }
 
-  await runClaimedTask({
-    projectDir,
-    mem,
-    config,
-    workerId,
-    mcpxClient,
-    callbacks,
-    task,
-  });
+  const mem = openMembot(resolveMembotDir(projectDir, config));
+  await mem.connect();
+  try {
+    await runClaimedTask({
+      projectDir,
+      withMem: sharedWithMem(mem),
+      config,
+      workerId,
+      mcpxClient,
+      callbacks,
+      task,
+    });
+  } finally {
+    await mem.close();
+  }
 
   const elapsed = ((Date.now() - tickStart) / 1000).toFixed(1);
   logger.phase("tick-end", `#${tickNum} ${elapsed}s didWork=true`);
@@ -95,7 +109,6 @@ export async function tick(opts: TickOptions): Promise<boolean> {
  */
 export async function runSpecificTask(opts: {
   projectDir: string;
-  mem: MembotClient;
   config: Required<BotholomewConfig>;
   workerId: string;
   taskId: string;
@@ -113,28 +126,34 @@ export async function runSpecificTask(opts: {
     );
     return false;
   }
-  await runClaimedTask({
-    projectDir: opts.projectDir,
-    mem: opts.mem,
-    config: opts.config,
-    workerId: opts.workerId,
-    mcpxClient: opts.mcpxClient,
-    callbacks: opts.callbacks,
-    task,
-  });
+  const mem = openMembot(resolveMembotDir(opts.projectDir, opts.config));
+  await mem.connect();
+  try {
+    await runClaimedTask({
+      projectDir: opts.projectDir,
+      withMem: sharedWithMem(mem),
+      config: opts.config,
+      workerId: opts.workerId,
+      mcpxClient: opts.mcpxClient,
+      callbacks: opts.callbacks,
+      task,
+    });
+  } finally {
+    await mem.close();
+  }
   return true;
 }
 
 async function runClaimedTask(opts: {
   projectDir: string;
-  mem: MembotClient;
+  withMem: WithMem;
   config: Required<BotholomewConfig>;
   workerId: string;
   mcpxClient?: McpxClient | null;
   callbacks?: WorkerStreamCallbacks;
   task: Task;
 }): Promise<void> {
-  const { projectDir, mem, config, workerId, mcpxClient, callbacks, task } =
+  const { projectDir, withMem, config, workerId, mcpxClient, callbacks, task } =
     opts;
 
   logger.info(`Claimed task: ${task.name} (${task.id})`);
@@ -172,7 +191,7 @@ async function runClaimedTask(opts: {
       systemPrompt,
       task,
       config,
-      mem,
+      withMem,
       threadId,
       projectDir,
       workerId,