botholomew 0.7.12 → 0.8.0

package/src/tui/App.tsx

@@ -6,7 +6,6 @@ import {
   sendMessage,
   startChatSession,
 } from "../chat/session.ts";
-import { MAX_INLINE_CHARS, PAGE_SIZE_CHARS } from "../daemon/large-results.ts";
 import { withDb } from "../db/connection.ts";
 import type { Interaction } from "../db/threads.ts";
 import { getThread } from "../db/threads.ts";
@@ -15,6 +14,7 @@ import {
   handleSlashCommand,
   type SlashCommand,
 } from "../skills/commands.ts";
+import { MAX_INLINE_CHARS, PAGE_SIZE_CHARS } from "../worker/large-results.ts";
 import { ContextPanel } from "./components/ContextPanel.tsx";
 import { HelpPanel } from "./components/HelpPanel.tsx";
 import { InputBar } from "./components/InputBar.tsx";
@@ -32,6 +32,7 @@ import { TaskPanel } from "./components/TaskPanel.tsx";
 import { ThreadPanel } from "./components/ThreadPanel.tsx";
 import type { ToolCallData } from "./components/ToolCall.tsx";
 import { ToolPanel } from "./components/ToolPanel.tsx";
+import { WorkerPanel } from "./components/WorkerPanel.tsx";
 import { buildSlashCommands, getSlashMatches } from "./slashCompletion.ts";
 import { ansi } from "./theme.ts";
 
@@ -136,7 +137,7 @@ export function App({
   const [error, setError] = useState<string | null>(null);
   const sessionRef = useRef<ChatSession | null>(null);
   const [activeTab, setActiveTab] = useState<TabId>(1);
-  const [daemonRunning, setDaemonRunning] = useState(false);
+  const [workerRunning, setWorkerRunning] = useState(false);
   const [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
   const queueRef = useRef<string[]>([]);
   const processingRef = useRef(false);
@@ -222,7 +223,7 @@ export function App({
     const [dwellRaw, delayRaw] = spec.split(":");
     const dwellMs = Number.parseInt(dwellRaw ?? "", 10) || 2500;
     const startDelayMs = Number.parseInt(delayRaw ?? "", 10) || 0;
-    const sequence: TabId[] = [2, 3, 4, 5, 6, 7, 1];
+    const sequence: TabId[] = [2, 3, 4, 5, 6, 7, 8, 1];
     const timers = sequence.map((tab, i) =>
       setTimeout(() => setActiveTab(tab), startDelayMs + dwellMs * (i + 1)),
     );
@@ -262,7 +263,7 @@ export function App({
           );
           if (popupOpen) return;
         }
-        setActiveTab((t) => ((t % 7) + 1) as TabId);
+        setActiveTab((t) => ((t % 8) + 1) as TabId);
         return;
       }
 
@@ -299,7 +300,7 @@ export function App({
       if (tab !== 1) {
         // Number keys jump to tab on non-chat tabs
         const num = Number.parseInt(input, 10);
-        if (num >= 1 && num <= 7) {
+        if (num >= 1 && num <= 8) {
           setActiveTab(num as TabId);
           return;
         }
@@ -582,7 +583,7 @@ export function App({
           projectDir={projectDir}
           dbPath={sessionDbPath}
           chatTitle={chatTitle}
-          onDaemonStatusChange={setDaemonRunning}
+          onWorkerStatusChange={setWorkerRunning}
         />
       ) : null,
     [projectDir, sessionDbPath, chatTitle],
@@ -700,11 +701,18 @@ export function App({
         display={activeTab === 7 ? "flex" : "none"}
         flexDirection="column"
         flexGrow={1}
+      >
+        <WorkerPanel dbPath={dbPath} isActive={activeTab === 7} />
+      </Box>
+      <Box
+        display={activeTab === 8 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
       >
         <HelpPanel
           projectDir={projectDir}
           threadId={threadId}
-          daemonRunning={daemonRunning}
+          workerRunning={workerRunning}
         />
       </Box>
 

package/src/tui/components/ContextPanel.tsx

@@ -272,13 +272,17 @@ export const ContextPanel = memo(function ContextPanel({
           {visibleItems.map((item, vi) => {
             const i = vi + scrollOffset;
             const ci = item as ContextItem;
+            const slashIdx = ci.context_path.lastIndexOf("/");
+            const dir =
+              slashIdx >= 0 ? ci.context_path.slice(0, slashIdx + 1) : "";
             return (
               <Box key={ci.id}>
                 <Text
                   backgroundColor={i === cursor ? "#333" : undefined}
                   color={i === cursor ? "cyan" : undefined}
                 >
-                  {"  "}📄 {ci.context_path}
+                  {"  "}📄 <Text dimColor>{dir}</Text>
+                  {ci.title}
                   <Text dimColor> ({ci.mime_type})</Text>
                 </Text>
               </Box>

package/src/tui/components/HelpPanel.tsx

@@ -4,13 +4,13 @@ import { memo } from "react";
 interface HelpPanelProps {
   projectDir: string;
   threadId: string;
-  daemonRunning: boolean;
+  workerRunning: boolean;
 }
 
 export const HelpPanel = memo(function HelpPanel({
   projectDir,
   threadId,
-  daemonRunning,
+  workerRunning,
 }: HelpPanelProps) {
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={1} overflow="hidden">
@@ -153,11 +153,11 @@ export const HelpPanel = memo(function HelpPanel({
           {threadId}
         </Text>
         <Text>
-          {"  "}Daemon{"    "}
-          {daemonRunning ? (
+          {"  "}Workers{"   "}
+          {workerRunning ? (
             <Text color="green">running</Text>
           ) : (
-            <Text color="red">off</Text>
+            <Text color="yellow">none</Text>
           )}
         </Text>
       </Box>

package/src/tui/components/StatusBar.tsx

@@ -2,30 +2,30 @@ import { Box, Text } from "ink";
 import { useEffect, useState } from "react";
 import { withDb } from "../../db/connection.ts";
 import { listTasks } from "../../db/tasks.ts";
-import { getDaemonStatus } from "../../utils/pid.ts";
+import { listWorkers } from "../../db/workers.ts";
 import { LogoChar } from "./Logo.tsx";
 
 interface StatusBarProps {
   projectDir: string;
   dbPath: string;
   chatTitle?: string;
-  onDaemonStatusChange?: (running: boolean) => void;
+  onWorkerStatusChange?: (running: boolean) => void;
 }
 
 interface Status {
-  daemonRunning: boolean;
+  workerCount: number;
   pendingCount: number;
   inProgressCount: number;
 }
 
 export function StatusBar({
-  projectDir,
+  projectDir: _projectDir,
   dbPath,
   chatTitle,
-  onDaemonStatusChange,
+  onWorkerStatusChange,
 }: StatusBarProps) {
   const [status, setStatus] = useState<Status>({
-    daemonRunning: false,
+    workerCount: 0,
     pendingCount: 0,
     inProgressCount: 0,
   });
@@ -34,19 +34,21 @@ export function StatusBar({
     let mounted = true;
 
     const refresh = async () => {
-      const daemon = await getDaemonStatus(projectDir);
-      const [pending, inProgress] = await withDb(dbPath, async (conn) => [
-        await listTasks(conn, { status: "pending" }),
-        await listTasks(conn, { status: "in_progress" }),
-      ]);
+      const [pending, inProgress, workers] = await withDb(
+        dbPath,
+        async (conn) => [
+          await listTasks(conn, { status: "pending" }),
+          await listTasks(conn, { status: "in_progress" }),
+          await listWorkers(conn, { status: "running" }),
+        ],
+      );
       if (mounted) {
-        const daemonRunning = daemon !== null;
         setStatus({
-          daemonRunning,
+          workerCount: workers.length,
           pendingCount: pending.length,
           inProgressCount: inProgress.length,
         });
-        onDaemonStatusChange?.(daemonRunning);
+        onWorkerStatusChange?.(workers.length > 0);
       }
     };
 
@@ -56,7 +58,7 @@ export function StatusBar({
       mounted = false;
       clearInterval(interval);
     };
-  }, [projectDir, dbPath, onDaemonStatusChange]);
+  }, [dbPath, onWorkerStatusChange]);
 
   return (
     <Box paddingX={0}>
@@ -73,10 +75,12 @@ export function StatusBar({
         </>
       )}
       <Text dimColor> | </Text>
-      {status.daemonRunning ? (
-        <Text color="green">Daemon</Text>
+      {status.workerCount > 0 ? (
+        <Text color="green">
+          {status.workerCount} worker{status.workerCount === 1 ? "" : "s"}
+        </Text>
       ) : (
-        <Text color="red">Daemon (off)</Text>
+        <Text color="yellow">no workers</Text>
       )}
       <Text dimColor> | </Text>
       <Text>

package/src/tui/components/TabBar.tsx

@@ -1,6 +1,6 @@
 import { Box, Text } from "ink";
 
-export type TabId = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type TabId = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 
 const TABS: { id: TabId; label: string }[] = [
   { id: 1, label: "Chat" },
@@ -9,7 +9,8 @@ const TABS: { id: TabId; label: string }[] = [
   { id: 4, label: "Tasks" },
   { id: 5, label: "Threads" },
   { id: 6, label: "Schedules" },
-  { id: 7, label: "Help" },
+  { id: 7, label: "Workers" },
+  { id: 8, label: "Help" },
 ];
 
 interface TabBarProps {

package/src/tui/components/ThreadPanel.tsx

@@ -22,27 +22,27 @@ const SIDEBAR_WIDTH = 42;
 const PAGE_SCROLL_LINES = 10;
 
 const THREAD_TYPES: readonly Thread["type"][] = [
-  "daemon_tick",
+  "worker_tick",
   "chat_session",
 ] as const;
 
 const TYPE_LABELS: Record<Thread["type"], string> = {
-  daemon_tick: "daemon",
-  chat_session: "agent",
+  worker_tick: "worker",
+  chat_session: "chat",
 };
 
 const TYPE_ICONS: Record<Thread["type"], string> = {
-  daemon_tick: "⚙",
+  worker_tick: "⚙",
   chat_session: "💬",
 };
 
 const TYPE_COLORS: Record<Thread["type"], string> = {
-  daemon_tick: theme.accent,
+  worker_tick: theme.accent,
   chat_session: theme.info,
 };
 
 const TYPE_ANSI: Record<Thread["type"], string> = {
-  daemon_tick: ansi.accent,
+  worker_tick: ansi.accent,
   chat_session: ansi.info,
 };
 
@@ -481,7 +481,7 @@ export const ThreadPanel = memo(function ThreadPanel({
             ? `No threads match "${searchQuery}". Press Escape to clear search.`
             : typeFilter
               ? "No threads match the current filter. Press f to change filter."
-              : "No threads found. Threads will appear as chat sessions and daemon ticks occur."}
+              : "No threads found. Threads will appear as chat sessions and worker ticks occur."}
         </Text>
         {typeFilter && (
           <Box marginTop={1}>

package/src/tui/components/WorkerPanel.tsx

@@ -0,0 +1,207 @@
+import { Box, Text, useInput, useStdout } from "ink";
+import { memo, useEffect, useState } from "react";
+import { withDb } from "../../db/connection.ts";
+import { listWorkers, type Worker } from "../../db/workers.ts";
+
+interface WorkerPanelProps {
+  dbPath: string;
+  isActive: boolean;
+}
+
+const STATUS_FILTERS: readonly (Worker["status"] | null)[] = [
+  null,
+  "running",
+  "stopped",
+  "dead",
+];
+
+function statusColor(status: Worker["status"]): string {
+  switch (status) {
+    case "running":
+      return "green";
+    case "stopped":
+      return "gray";
+    case "dead":
+      return "red";
+  }
+}
+
+function formatAge(from: Date, now: Date): string {
+  const secs = Math.max(0, Math.floor((now.getTime() - from.getTime()) / 1000));
+  if (secs < 60) return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+export const WorkerPanel = memo(function WorkerPanel({
+  dbPath,
+  isActive,
+}: WorkerPanelProps) {
+  const { stdout } = useStdout();
+  const termRows = stdout?.rows ?? 24;
+  const [workers, setWorkers] = useState<Worker[]>([]);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [filterIdx, setFilterIdx] = useState(0);
+  const [now, setNow] = useState(() => new Date());
+
+  useEffect(() => {
+    let mounted = true;
+
+    const refresh = async () => {
+      const status = STATUS_FILTERS[filterIdx] ?? undefined;
+      const result = await withDb(dbPath, (conn) =>
+        listWorkers(conn, status ? { status } : {}),
+      );
+      if (mounted) {
+        setWorkers(result);
+        setNow(new Date());
+        setSelectedIndex((prev) =>
+          Math.min(prev, Math.max(0, result.length - 1)),
+        );
+      }
+    };
+
+    refresh();
+    const interval = setInterval(refresh, 3000);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [dbPath, filterIdx]);
+
+  useInput(
+    (input, key) => {
+      if (!isActive) return;
+      if (key.upArrow) {
+        setSelectedIndex((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setSelectedIndex((i) => Math.min(workers.length - 1, i + 1));
+        return;
+      }
+      if (input === "f") {
+        setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
+        return;
+      }
+    },
+    { isActive },
+  );
+
+  const selected = workers[selectedIndex];
+  const filterLabel = STATUS_FILTERS[filterIdx] ?? "all";
+  const visibleRows = Math.max(4, termRows - 10);
+
+  return (
+    <Box flexDirection="column" flexGrow={1} paddingX={1}>
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          Workers
+        </Text>
+        <Text dimColor> · filter: </Text>
+        <Text color="yellow">{filterLabel}</Text>
+        <Text dimColor>{" · [f] cycle filter  [↑↓] select"}</Text>
+      </Box>
+
+      {workers.length === 0 ? (
+        <Text dimColor>
+          No workers
+          {filterLabel !== "all" ? ` with status "${filterLabel}"` : ""}.{"\n"}
+          Start one with{" "}
+          <Text color="green">botholomew worker start --persist</Text>.
+        </Text>
+      ) : (
+        <Box flexDirection="row" flexGrow={1}>
+          <Box
+            flexDirection="column"
+            width={44}
+            marginRight={2}
+            overflow="hidden"
+          >
+            {workers.slice(0, visibleRows).map((w, i) => {
+              const active = i === selectedIndex;
+              const short = w.id.slice(0, 8);
+              return (
+                <Box key={w.id}>
+                  <Text
+                    color={active ? "cyan" : undefined}
+                    bold={active}
+                    backgroundColor={active ? "#1a3a5c" : undefined}
+                  >
+                    {active ? "›" : " "}{" "}
+                  </Text>
+                  <Text
+                    color={statusColor(w.status)}
+                    dimColor={!active && w.status !== "running"}
+                  >
+                    {w.status.padEnd(8)}
+                  </Text>
+                  <Text dimColor> </Text>
+                  <Text>{short}</Text>
+                  <Text dimColor>{` ${w.mode.padEnd(7)}`}</Text>
+                  <Text dimColor>{formatAge(w.last_heartbeat_at, now)}</Text>
+                </Box>
+              );
+            })}
+          </Box>
+          <Box flexDirection="column" flexGrow={1}>
+            {selected ? <WorkerDetail worker={selected} now={now} /> : null}
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+});
+
+function WorkerDetail({ worker, now }: { worker: Worker; now: Date }) {
+  return (
+    <Box flexDirection="column">
+      <Text bold color="blue">
+        {worker.id}
+      </Text>
+      <Box marginTop={1} flexDirection="column">
+        <Text>
+          <Text dimColor>Status </Text>
+          <Text color={statusColor(worker.status)}>{worker.status}</Text>
+        </Text>
+        <Text>
+          <Text dimColor>Mode </Text>
+          {worker.mode}
+        </Text>
+        <Text>
+          <Text dimColor>PID </Text>
+          {worker.pid}
+        </Text>
+        <Text>
+          <Text dimColor>Host </Text>
+          {worker.hostname}
+        </Text>
+        <Text>
+          <Text dimColor>Started </Text>
+          {worker.started_at.toISOString()}{" "}
+          <Text dimColor>({formatAge(worker.started_at, now)} ago)</Text>
+        </Text>
+        <Text>
+          <Text dimColor>Heartbeat</Text>{" "}
+          {worker.last_heartbeat_at.toISOString()}{" "}
+          <Text dimColor>({formatAge(worker.last_heartbeat_at, now)} ago)</Text>
+        </Text>
+        {worker.stopped_at && (
+          <Text>
+            <Text dimColor>Stopped </Text>
+            {worker.stopped_at.toISOString()}
+          </Text>
+        )}
+        {worker.task_id && (
+          <Text>
+            <Text dimColor>Task </Text>
+            {worker.task_id}
+          </Text>
+        )}
+      </Box>
+    </Box>
+  );
+}

package/src/utils/title.ts

@@ -1,7 +1,7 @@
 import type { BotholomewConfig } from "../config/schemas.ts";
-import { createLlmClient } from "../daemon/llm-client.ts";
 import { withDb } from "../db/connection.ts";
 import { updateThreadTitle } from "../db/threads.ts";
+import { createLlmClient } from "../worker/llm-client.ts";
 import { logger } from "./logger.ts";
 
 /**

package/src/worker/heartbeat.ts

@@ -0,0 +1,78 @@
+import { withDb } from "../db/connection.ts";
+import {
+  heartbeat,
+  pruneStoppedWorkers,
+  reapDeadWorkers,
+} from "../db/workers.ts";
+import { logger } from "../utils/logger.ts";
+
+/**
+ * Start a non-blocking heartbeat interval for a running worker.
+ *
+ * The heartbeat runs on its own `setInterval` timer so it stays live even
+ * while the worker is blocked inside a long LLM call. We `unref` the timer
+ * so it doesn't keep the Bun event loop alive on its own — the main tick
+ * loop (or the awaited one-shot task) is what keeps the process running.
+ *
+ * Errors are swallowed with a warning: a transient DB lock shouldn't crash
+ * a worker that's otherwise doing useful work. If every heartbeat fails the
+ * worker will eventually be reaped, which is the correct outcome.
+ */
+export function startHeartbeat(
+  dbPath: string,
+  workerId: string,
+  intervalSeconds: number,
+): () => void {
+  const ms = Math.max(1_000, intervalSeconds * 1_000);
+  const handle = setInterval(async () => {
+    try {
+      await withDb(dbPath, (conn) => heartbeat(conn, workerId));
+    } catch (err) {
+      logger.warn(`worker heartbeat failed: ${err}`);
+    }
+  }, ms);
+  handle.unref?.();
+  return () => clearInterval(handle);
+}
+
+/**
+ * Start a periodic reaper that marks stale workers dead and releases any
+ * tasks / schedule claims they held. Only persist workers need this — a
+ * one-shot worker does a single reap pass before claiming its task.
+ */
+export function startReaper(
+  dbPath: string,
+  intervalSeconds: number,
+  staleAfterSeconds: number,
+  stoppedRetentionSeconds: number,
+): () => void {
+  const ms = Math.max(1_000, intervalSeconds * 1_000);
+  const handle = setInterval(async () => {
+    try {
+      const reaped = await withDb(dbPath, (conn) =>
+        reapDeadWorkers(conn, staleAfterSeconds),
+      );
+      if (reaped.length > 0) {
+        logger.warn(
+          `reaped ${reaped.length} stale worker(s): ${reaped.join(", ")}`,
+        );
+      }
+    } catch (err) {
+      logger.warn(`worker reap failed: ${err}`);
+    }
+    try {
+      const pruned = await withDb(dbPath, (conn) =>
+        pruneStoppedWorkers(conn, stoppedRetentionSeconds),
+      );
+      if (pruned.length > 0) {
+        logger.debug(
+          `pruned ${pruned.length} old stopped worker(s): ${pruned.join(", ")}`,
+        );
+      }
+    } catch (err) {
+      logger.warn(`worker prune failed: ${err}`);
+    }
+  }, ms);
+  handle.unref?.();
+  return () => clearInterval(handle);
+}