botholomew 0.16.4 → 0.18.0

package/src/tui/components/ContextPanel.tsx

@@ -1,20 +1,7 @@
 import { Box, Text, useInput } from "ink";
+import type { MembotClient } from "membot";
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
-import { getDbPath } from "../../constants.ts";
-import {
-  type ContextEntry,
-  deleteContextPath,
-  listContextDir,
-  readContextFile,
-} from "../../context/store.ts";
-import { withDb } from "../../db/connection.ts";
-import {
-  deleteIndexedPath,
-  deleteIndexedPathsUnder,
-  getIndexedPath,
-  type IndexedPathSummary,
-  rebuildSearchIndex,
-} from "../../db/embeddings.ts";
+import { openMembot } from "../../mem/client.ts";
 import {
   detailPaneBorderProps,
   type FocusState,
@@ -34,9 +21,24 @@ interface ContextPanelProps {
   isActive: boolean;
 }
 
-const SIDEBAR_WIDTH = 32;
+interface ContextEntry {
+  logical_path: string;
+  version_id: string;
+  size_bytes: number | null;
+  mime_type: string | null;
+  description: string | null;
+}
+
+const SIDEBAR_WIDTH = 40;
 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.
+ */
 export const ContextPanel = memo(function ContextPanel({
   projectDir,
   isActive,
@@ -44,51 +46,55 @@ export const ContextPanel = memo(function ContextPanel({
   const { rows: termRows, cols: termCols } = useTerminalSize();
   const detailWidth = Math.max(1, termCols - SIDEBAR_WIDTH - 5);
 
-  const [currentPath, setCurrentPath] = useState("");
+  // 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);
+  useEffect(() => {
+    const c = openMembot(projectDir);
+    setClient(c);
+    return () => {
+      void c.close();
+    };
+  }, [projectDir]);
+
   const [entries, setEntries] = useState<ContextEntry[]>([]);
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [sidebarScrollOffset, setSidebarScrollOffset] = useState(0);
   const [detailScroll, setDetailScroll] = useState(0);
   const [focus, setFocus] = useState<FocusState>("list");
   const [fileContent, setFileContent] = useState<{
-    path: string;
+    logical_path: string;
     content: string;
   } | null>(null);
-  const [indexStatus, setIndexStatus] = useState<{
-    path: string;
-    summary: IndexedPathSummary | null;
-  } | null>(null);
 
   const visibleRows = Math.max(1, termRows - 6);
 
-  const refresh = useCallback(
-    async (path: string) => {
-      try {
-        const list = await listContextDir(projectDir, path, {
-          recursive: false,
-        });
-        list.sort((a, b) => {
-          if (a.is_directory !== b.is_directory) return a.is_directory ? -1 : 1;
-          return a.path.localeCompare(b.path);
-        });
-        setEntries(list);
-        setSelectedIndex(0);
-        setSidebarScrollOffset(0);
-      } catch {
-        setEntries([]);
-        setSelectedIndex(0);
-        setSidebarScrollOffset(0);
-      }
-    },
-    [projectDir],
-  );
+  const refresh = useCallback(async () => {
+    if (!client) return;
+    try {
+      const out = await client.list({ limit: 500 });
+      const list = out.entries.map((e) => ({
+        logical_path: e.logical_path,
+        version_id: e.version_id,
+        size_bytes: e.size_bytes,
+        mime_type: e.mime_type,
+        description: e.description,
+      }));
+      list.sort((a, b) => a.logical_path.localeCompare(b.logical_path));
+      setEntries(list);
+      setSelectedIndex(0);
+      setSidebarScrollOffset(0);
+    } catch {
+      setEntries([]);
+      setSelectedIndex(0);
+      setSidebarScrollOffset(0);
+    }
+  }, [client]);
 
   useEffect(() => {
-    refresh(currentPath);
-  }, [currentPath, refresh]);
+    refresh();
+  }, [refresh]);
 
-  // Keep the sidebar's selection visible by scrolling its viewport when the
-  // cursor approaches the edges.
   useEffect(() => {
     if (selectedIndex < sidebarScrollOffset) {
       setSidebarScrollOffset(selectedIndex);
@@ -99,57 +105,38 @@ export const ContextPanel = memo(function ContextPanel({
 
   const selectedEntry = entries[selectedIndex];
 
-  // Auto-load file content when the selection lands on a textual file.
-  // Folders and non-textual files clear the right pane.
   useEffect(() => {
     let cancelled = false;
-    if (!selectedEntry) {
-      setFileContent(null);
-      setDetailScroll(0);
-      return;
-    }
-    if (selectedEntry.is_directory || !selectedEntry.is_textual) {
+    if (!selectedEntry || !client) {
       setFileContent(null);
       setDetailScroll(0);
       return;
     }
     setDetailScroll(0);
-    readContextFile(projectDir, selectedEntry.path).then((content) => {
-      if (cancelled) return;
-      setFileContent({ path: selectedEntry.path, content });
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [projectDir, selectedEntry]);
-
-  // Look up the file's index status so we can show "indexed (N chunks)"
-  // vs "not indexed" in the header. Skips for folders.
-  useEffect(() => {
-    let cancelled = false;
-    if (!selectedEntry || selectedEntry.is_directory) {
-      setIndexStatus(null);
-      return;
-    }
-    const path = selectedEntry.path;
-    const dbPath = getDbPath(projectDir);
-    withDb(dbPath, (conn) => getIndexedPath(conn, path))
-      .then((summary) => {
+    client
+      .read({ logical_path: selectedEntry.logical_path })
+      .then((result) => {
         if (cancelled) return;
-        setIndexStatus({ path, summary });
+        setFileContent({
+          logical_path: selectedEntry.logical_path,
+          content: result.content ?? "",
+        });
       })
       .catch(() => {
         if (cancelled) return;
-        setIndexStatus({ path, summary: null });
+        setFileContent({
+          logical_path: selectedEntry.logical_path,
+          content: "(failed to read this entry — it may have been removed)",
+        });
       });
     return () => {
       cancelled = true;
     };
-  }, [projectDir, selectedEntry]);
+  }, [client, selectedEntry]);
 
   const detailLines = useMemo(() => {
     if (!fileContent || !selectedEntry) return [];
-    const body = isMarkdownPath(fileContent.path)
+    const body = isMarkdownPath(fileContent.logical_path)
       ? renderMarkdown(fileContent.content)
       : fileContent.content;
     return wrapDetailLines(body, detailWidth);
@@ -163,34 +150,22 @@ export const ContextPanel = memo(function ContextPanel({
     [entries, sidebarScrollOffset, visibleRows],
   );
 
-  // Refs read by the keyboard handler so it always sees the latest committed
-  // values (Ink 7's useInput intermittently leaves a stale closure).
   const itemCountRef = useLatestRef(entries.length);
   const maxDetailScrollRef = useLatestRef(maxDetailScroll);
   const selectedEntryRef = useLatestRef(selectedEntry);
-  const currentPathRef = useLatestRef(currentPath);
   const focusRef = useLatestRef(focus);
 
   const deleteConfirm = useDeleteConfirm(() => {
     const entry = selectedEntryRef.current;
-    if (!entry) return;
-    const path = entry.path;
-    const isDirectory = entry.is_directory;
+    if (!entry || !client) return;
+    const path = entry.logical_path;
     (async () => {
       try {
-        await deleteContextPath(projectDir, path, { recursive: isDirectory });
-        await withDb(getDbPath(projectDir), async (conn) => {
-          if (isDirectory) {
-            await deleteIndexedPathsUnder(conn, path);
-          } else {
-            await deleteIndexedPath(conn, path);
-          }
-          await rebuildSearchIndex(conn);
-        });
+        await client.remove({ paths: [path] });
       } catch {
         // ignore — refresh will reflect any partial state
       }
-      refresh(currentPathRef.current);
+      refresh();
     })();
   });
 
@@ -207,26 +182,6 @@ export const ContextPanel = memo(function ContextPanel({
           setSelectedIndex,
           setDetailScroll,
           pageScrollLines: PAGE_SCROLL_LINES,
-          // Context-specific: → on a folder drills in (when list-focused);
-          // ← in list-focus goes up a directory.
-          onRightArrow: () => {
-            if (focusRef.current !== "list") return false;
-            const entry = selectedEntryRef.current;
-            if (entry?.is_directory) {
-              setCurrentPath(entry.path);
-              return true;
-            }
-            return false;
-          },
-          onLeftArrow: () => {
-            if (focusRef.current !== "list") return false;
-            const cwd = currentPathRef.current;
-            if (cwd === "") return true; // already at root, swallow the key
-            const parts = cwd.split("/");
-            parts.pop();
-            setCurrentPath(parts.join("/"));
-            return true;
-          },
         })
       ) {
         return;
@@ -235,20 +190,17 @@ export const ContextPanel = memo(function ContextPanel({
       if (input === "d") {
         const entry = selectedEntryRef.current;
         if (!entry) return;
-        deleteConfirm.pressDelete(entry.path);
+        deleteConfirm.pressDelete(entry.logical_path);
         return;
       }
       if (key.ctrl && (input === "r" || input === "R")) {
-        refresh(currentPathRef.current);
+        refresh();
         return;
       }
     },
     { isActive },
   );
 
-  const headerLabel =
-    currentPath === "" ? "context/" : `context/${currentPath}/`;
-
   const detailVisible = detailLines.slice(
     detailScroll,
     detailScroll + visibleDetailRows,
@@ -256,7 +208,6 @@ export const ContextPanel = memo(function ContextPanel({
 
   return (
     <Box flexGrow={1} height={visibleRows + 1} overflow="hidden">
-      {/* Left: file tree */}
       <Box
         flexDirection="column"
         width={SIDEBAR_WIDTH}
@@ -271,35 +222,26 @@ export const ContextPanel = memo(function ContextPanel({
       >
         <Box paddingX={1}>
           <Text bold dimColor wrap="truncate-end">
-            {headerLabel}
+            membot ({entries.length})
           </Text>
         </Box>
         {entries.length === 0 ? (
           <Box paddingX={1}>
-            <Text dimColor>(empty)</Text>
+            <Text dimColor>(empty — try `botholomew context add …`)</Text>
           </Box>
         ) : (
           visibleItems.map((entry, vi) => {
             const i = vi + sidebarScrollOffset;
             const isSelected = i === selectedIndex;
-            const name = entry.path.split("/").pop() ?? entry.path;
-            const icon = entry.is_directory ? "📁" : "📄";
             return (
-              <Box key={entry.path} paddingX={1}>
+              <Box key={entry.logical_path} paddingX={1}>
                 <Text
                   backgroundColor={isSelected ? theme.selectionBg : undefined}
-                  color={
-                    isSelected
-                      ? theme.info
-                      : entry.is_directory
-                        ? theme.accent
-                        : undefined
-                  }
+                  color={isSelected ? theme.info : undefined}
                   bold={isSelected}
                   wrap="truncate-end"
                 >
-                  {isSelected ? "▸" : " "} {icon} {name}
-                  {entry.is_directory ? "/" : ""}
+                  {isSelected ? "▸" : " "} {entry.logical_path}
                 </Text>
               </Box>
             );
@@ -307,7 +249,6 @@ export const ContextPanel = memo(function ContextPanel({
         )}
       </Box>
 
-      {/* Right: file content (or placeholder) */}
       <Box
         flexDirection="column"
         flexGrow={1}
@@ -318,49 +259,29 @@ export const ContextPanel = memo(function ContextPanel({
       >
         {selectedEntry ? (
           <>
-            <ContextDetailHeader
-              entry={selectedEntry}
-              indexStatus={
-                indexStatus && indexStatus.path === selectedEntry.path
-                  ? indexStatus.summary
-                  : null
-              }
-              indexLoaded={
-                !!indexStatus && indexStatus.path === selectedEntry.path
-              }
-            />
+            <ContextDetailHeader entry={selectedEntry} />
             <Box flexDirection="row" flexGrow={1} overflow="hidden">
               <Box flexDirection="column" flexGrow={1} overflow="hidden">
-                {selectedEntry.is_directory ? (
-                  <Text dimColor>(folder — press → to drill in)</Text>
-                ) : !selectedEntry.is_textual ? (
-                  <Text dimColor>(binary file — no preview)</Text>
-                ) : (
-                  detailVisible.map((line, i) => {
-                    const lineNum = detailScroll + i;
-                    return (
-                      <Text key={lineNum} wrap="truncate-end">
-                        {line || " "}
-                      </Text>
-                    );
-                  })
-                )}
+                {detailVisible.map((line, i) => {
+                  const lineNum = detailScroll + i;
+                  return (
+                    <Text key={lineNum} wrap="truncate-end">
+                      {line || " "}
+                    </Text>
+                  );
+                })}
               </Box>
-              {selectedEntry &&
-                !selectedEntry.is_directory &&
-                selectedEntry.is_textual && (
-                  <Scrollbar
-                    total={detailLines.length}
-                    visible={visibleDetailRows - 3}
-                    offset={detailScroll}
-                    height={visibleDetailRows - 3}
-                    focused={focus === "detail"}
-                  />
-                )}
+              <Scrollbar
+                total={detailLines.length}
+                visible={visibleDetailRows - 3}
+                offset={detailScroll}
+                height={visibleDetailRows - 3}
+                focused={focus === "detail"}
+              />
             </Box>
           </>
         ) : (
-          <Text dimColor>(no item selected)</Text>
+          <Text dimColor>(no entry selected)</Text>
         )}
         <DeleteArmedBanner
           armed={deleteConfirm.armed}
@@ -370,7 +291,7 @@ export const ContextPanel = memo(function ContextPanel({
           <Text dimColor>
             {focus === "detail"
               ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-              : "↑↓ select · → drill in/enter detail · ← up · d delete (×2) · ^R refresh"}
+              : "↑↓ select · → detail · d delete (×2) · ^R refresh"}
           </Text>
         </Box>
       </Box>
@@ -378,72 +299,34 @@ export const ContextPanel = memo(function ContextPanel({
   );
 });
 
-function formatSize(bytes: number): string {
+function formatSize(bytes: number | null): string {
+  if (bytes === null) return "-";
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-function formatDate(d: Date): string {
-  return d.toLocaleString([], {
-    month: "short",
-    day: "numeric",
-    hour: "2-digit",
-    minute: "2-digit",
-  });
-}
-
-function ContextDetailHeader({
-  entry,
-  indexStatus,
-  indexLoaded,
-}: {
-  entry: ContextEntry;
-  indexStatus: IndexedPathSummary | null;
-  indexLoaded: boolean;
-}) {
+function ContextDetailHeader({ entry }: { entry: ContextEntry }) {
   return (
     <Box flexDirection="column" width="100%" backgroundColor={theme.headerBg}>
       <Box>
         <Text bold color="cyan" wrap="truncate-end">
-          {entry.is_directory ? "📁" : "📄"} context/{entry.path}
-          {entry.is_directory ? "/" : ""}
+          📄 {entry.logical_path}
+        </Text>
+      </Box>
+      <Box>
+        <Text dimColor wrap="truncate-end">
+          {entry.mime_type ?? "?"} · {formatSize(entry.size_bytes)} · v=
+          {entry.version_id}
         </Text>
       </Box>
-      {entry.is_directory ? (
+      {entry.description ? (
         <Box>
           <Text dimColor wrap="truncate-end">
-            directory · → to open
+            {entry.description}
           </Text>
         </Box>
-      ) : (
-        <>
-          <Box>
-            <Text dimColor wrap="truncate-end">
-              {entry.mime_type} · {formatSize(entry.size)} · updated{" "}
-              {formatDate(entry.mtime)}
-            </Text>
-          </Box>
-          <Box>
-            <Text wrap="truncate-end">
-              {!indexLoaded ? (
-                <Text dimColor>checking index…</Text>
-              ) : indexStatus ? (
-                <Text color={theme.success}>
-                  ● indexed
-                  <Text dimColor>
-                    {" ("}
-                    {indexStatus.chunk_count}
-                    {indexStatus.chunk_count === 1 ? " chunk" : " chunks"})
-                  </Text>
-                </Text>
-              ) : (
-                <Text color={theme.muted}>○ not indexed</Text>
-              )}
-            </Text>
-          </Box>
-        </>
-      )}
+      ) : null}
     </Box>
   );
 }

package/src/tui/components/HelpPanel.tsx

@@ -149,8 +149,8 @@ export const HelpPanel = memo(function HelpPanel({
           {"  "}Tasks{"          "}f filter · p priority · d delete (×2)
         </Text>
         <Text>
-          {"  "}Threads{"        "}f filter · s/ search · w follow · d delete
-          (×2)
+          {"  "}Threads{"        "}f filter · s/ search · w tail live thread · d
+          delete (×2)
         </Text>
         <Text>
           {"  "}Schedules{"      "}f filter · e toggle · d delete (×2)

package/src/tui/components/StatusBar.tsx

@@ -7,11 +7,6 @@ import { LogoChar } from "./Logo.tsx";
 
 interface StatusBarProps {
   projectDir: string;
-  /**
-   * Retained for callers that pass it; unused now that workers + tasks
-   * both live on disk. Drop on the next TUI cleanup pass.
-   */
-  dbPath?: string;
   chatTitle?: string;
   onWorkerStatusChange?: (running: boolean) => void;
 }
@@ -24,7 +19,6 @@ interface Status {
 
 export function StatusBar({
   projectDir,
-  dbPath: _dbPath,
   chatTitle,
   onWorkerStatusChange,
 }: StatusBarProps) {

package/src/tui/components/ThreadPanel.tsx

@@ -18,7 +18,7 @@ import { ansi, theme } from "../theme.ts";
 import { useDeleteConfirm } from "../useDeleteConfirm.ts";
 import { useLatestRef } from "../useLatestRef.ts";
 import { useTerminalSize } from "../useTerminalSize.ts";
-import { wrapDetailLines } from "../wrapDetail.ts";
+import { clampScroll, wrapDetailLines } from "../wrapDetail.ts";
 import { DeleteArmedBanner } from "./DeleteArmedBanner.tsx";
 import { Scrollbar } from "./Scrollbar.tsx";
 
@@ -449,9 +449,10 @@ export const ThreadPanel = memo(function ThreadPanel({
     sidebarScrollOffset + visibleRows,
   );
 
+  const safeDetailScroll = clampScroll(detailScroll, maxDetailScroll);
   const detailVisible = detailLines.slice(
-    detailScroll,
-    detailScroll + visibleRows,
+    safeDetailScroll,
+    safeDetailScroll + visibleRows,
   );
 
   return (
@@ -547,7 +548,7 @@ export const ThreadPanel = memo(function ThreadPanel({
         <Box flexDirection="row" flexGrow={1} overflow="hidden">
           <Box flexDirection="column" flexGrow={1} overflow="hidden">
             {detailVisible.map((line, i) => {
-              const lineNum = detailScroll + i;
+              const lineNum = safeDetailScroll + i;
               return (
                 <Text key={lineNum} wrap="truncate-end">
                   {line || " "}
@@ -558,7 +559,7 @@ export const ThreadPanel = memo(function ThreadPanel({
           <Scrollbar
             total={detailLines.length}
             visible={visibleRows - 3}
-            offset={detailScroll}
+            offset={safeDetailScroll}
             height={visibleRows - 3}
             focused={focus === "detail"}
           />
@@ -571,13 +572,13 @@ export const ThreadPanel = memo(function ThreadPanel({
           {following && (
             <Text color={theme.success} bold>
               {" "}
-              FOLLOWING{" "}
+              ● TAILING{" "}
             </Text>
           )}
           <Text dimColor>
             {focus === "detail"
               ? "↑↓ scroll · ⇧↑↓ page · g/G top/bot · ← back to list"
-              : `↑↓ select · → enter detail · s search · f filter · d delete (×2)${selectedThread && !selectedThread.ended_at ? " · w follow" : ""} · ^R refresh`}
+              : `↑↓ select · → enter detail · s search · f filter · ${selectedThread && !selectedThread.ended_at ? "w tail (live) · " : ""}d delete (×2) · ^R refresh`}
           </Text>
         </Box>
       </Box>

package/src/tui/wrapDetail.ts

@@ -13,3 +13,14 @@ export function wrapDetailLines(text: string, width: number): string[] {
   if (width <= 0) return text.split("\n");
   return wrapAnsi(text, width, { hard: true, trim: false }).split("\n");
 }
+
+/**
+ * Clamp a scroll offset into the valid range for a detail pane. The Threads
+ * pane uses `Number.MAX_SAFE_INTEGER` as a "stay-at-bottom" sentinel during
+ * tail mode, and any panel can end up with an out-of-range scroll after a
+ * terminal resize shrinks `visibleRows`. Without clamping, `Array.slice`
+ * silently returns `[]`.
+ */
+export function clampScroll(scroll: number, maxScroll: number): number {
+  return Math.min(Math.max(0, scroll), Math.max(0, maxScroll));
+}

package/src/worker/heartbeat.ts

@@ -1,4 +1,3 @@
-import { reapOrphanContextLocks } from "../context/locks.ts";
 import { reapOrphanScheduleLocks } from "../schedules/store.ts";
 import { reapOrphanLocks as reapOrphanTaskLocks } from "../tasks/store.ts";
 import { logger } from "../utils/logger.ts";
@@ -82,25 +81,6 @@ export function startReaper(
       logger.warn(`schedule lock reap failed: ${err}`);
     }
 
-    try {
-      // Context locks store either a `workerId` (worker holders) or a
-      // free-form id like `chat` / `pid:<n>` (chat sessions, CLI). Only
-      // expire holders that look like worker ids; conservatively treat
-      // any other holder as alive — we don't manage the chat session's
-      // lifecycle here.
-      const released = await reapOrphanContextLocks(projectDir, async (id) => {
-        if (id.startsWith("pid:") || id.startsWith("chat")) return true;
-        return await isAlive(id);
-      });
-      if (released.length > 0) {
-        logger.warn(
-          `released ${released.length} orphan context lock(s): ${released.join(", ")}`,
-        );
-      }
-    } catch (err) {
-      logger.warn(`context lock reap failed: ${err}`);
-    }
-
     try {
       const pruned = await pruneStoppedWorkers(
         projectDir,