botholomew 0.18.2 → 0.18.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {

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/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)) {

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,8 +1,7 @@
 import { Box, Text, useInput } from "ink";
-import type { MembotClient } from "membot";
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import { loadConfig } from "../../config/loader.ts";
-import { openMembot, resolveMembotDir } from "../../mem/client.ts";
+import { resolveMembotDir, scopedWithMem } from "../../mem/client.ts";
 import {
   detailPaneBorderProps,
   type FocusState,
@@ -47,25 +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. The data dir is
-  // resolved from `membot_scope` (global → ~/.membot, project → <projectDir>)
-  // so the tab agrees with the worker / chat session / CLI.
-  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(() => {
     let cancelled = false;
-    let opened: MembotClient | null = null;
     (async () => {
       const config = await loadConfig(projectDir);
       if (cancelled) return;
-      opened = openMembot(resolveMembotDir(projectDir, config));
-      setClient(opened);
+      setMembotDir(resolveMembotDir(projectDir, config));
     })();
     return () => {
       cancelled = true;
-      if (opened) void opened.close();
     };
   }, [projectDir]);
+  const withMem = useMemo(
+    () => (membotDir ? scopedWithMem(membotDir) : null),
+    [membotDir],
+  );
 
   const [entries, setEntries] = useState<ContextEntry[]>([]);
   const [selectedIndex, setSelectedIndex] = useState(0);
@@ -80,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,
@@ -99,7 +99,7 @@ export const ContextPanel = memo(function ContextPanel({
       setSelectedIndex(0);
       setSidebarScrollOffset(0);
     }
-  }, [client]);
+  }, [withMem]);
 
   useEffect(() => {
     refresh();
@@ -117,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({
@@ -142,7 +141,7 @@ export const ContextPanel = memo(function ContextPanel({
     return () => {
       cancelled = true;
     };
-  }, [client, selectedEntry]);
+  }, [withMem, selectedEntry]);
 
   const detailLines = useMemo(() => {
     if (!fileContent || !selectedEntry) return [];
@@ -167,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
       }

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,