botholomew 0.9.11 → 0.9.12

package/package.json

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

package/src/commands/db.ts

@@ -3,11 +3,12 @@ import type { Command } from "commander";
 import { getDbPath } from "../constants.ts";
 import { withDb as coreWithDb } from "../db/connection.ts";
 import {
+  isPidAlive,
   type ProbeResult,
   probeAllTables,
   repairDatabase,
 } from "../db/doctor.ts";
-import { listWorkers } from "../db/workers.ts";
+import { listWorkers, type Worker } from "../db/workers.ts";
 import { logger } from "../utils/logger.ts";
 
 function statusBadge(status: ProbeResult["status"]): string {
@@ -78,28 +79,38 @@ async function doctor(program: Command, repair: boolean): Promise<void> {
     process.exit(1);
   }
 
-  // Repair requires exclusive access — refuse if any worker is registered
-  // as running, otherwise the EXPORT would race with the worker's writes.
+  // Repair requires exclusive access — refuse if any worker is actually
+  // running, otherwise the EXPORT would race with the worker's writes.
+  // Stale `status='running'` rows whose PID is dead (the exact case that
+  // tends to coexist with workers-table corruption) are reported but do
+  // not block repair: trying to flip them to `stopped` would just trip
+  // the same corruption we're about to fix.
   const running = await coreWithDb(dbPath, async (conn) => {
     try {
       return await listWorkers(conn, { status: "running" });
     } catch {
-      // If listWorkers itself trips the corruption we're about to fix,
-      // fall through and let repair proceed; the user is on their own
-      // for confirming no live workers, which `worker reap` would also
-      // be unable to do anyway.
-      return [];
+      return [] as Worker[];
     }
   });
-  if (running.length > 0) {
+  const live = running.filter((w) => isPidAlive(w.pid));
+  const stale = running.filter((w) => !isPidAlive(w.pid));
+  if (live.length > 0) {
     logger.error(
-      `${running.length} worker(s) registered as running. Stop them first: botholomew worker stop <id>`,
+      `${live.length} worker(s) actually running. Stop them first: botholomew worker stop <id>`,
     );
-    for (const w of running) {
+    for (const w of live) {
       logger.dim(`  ${w.id} (pid ${w.pid}, mode=${w.mode})`);
     }
     process.exit(1);
   }
+  if (stale.length > 0) {
+    logger.warn(
+      `${stale.length} worker row(s) marked 'running' but PID is dead — proceeding (rows will be carried through repair, then reapable):`,
+    );
+    for (const w of stale) {
+      logger.dim(`  ${w.id} (pid ${w.pid}, mode=${w.mode})`);
+    }
+  }
 
   logger.phase("repair", "EXPORT DATABASE → swap files → IMPORT DATABASE");
   const result = await repairDatabase(dbPath);

package/src/db/doctor.ts

@@ -85,12 +85,15 @@ export async function probeTable(
     }
   `;
 
+  // Discard the child's stderr. When the probe panics, Bun writes a multi-
+  // line crash banner there which would otherwise spill into our table
+  // output via the fallback message. The exit code alone tells us what we
+  // need to know.
   const proc = Bun.spawn(["bun", "-e", script], {
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: ["ignore", "pipe", "ignore"],
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
+  const [stdout, exitCode] = await Promise.all([
     new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
     proc.exited,
   ]);
 
@@ -103,20 +106,21 @@ export async function probeTable(
     return {
       table,
       status: "missing",
-      message: stdout.slice("MISSING:".length),
+      message: firstLine(stdout.slice("MISSING:".length)),
     };
   }
   if (stdout.startsWith("CORRUPT:")) {
     return {
       table,
       status: "corrupt",
-      message: stdout.slice("CORRUPT:".length),
+      message: firstLine(stdout.slice("CORRUPT:".length)),
     };
   }
-  const reason =
-    stderr.trim() ||
-    `child exited with code ${exitCode} and no verdict (likely native panic)`;
-  return { table, status: "corrupt", message: reason };
+  return {
+    table,
+    status: "corrupt",
+    message: `child exited with code ${exitCode} (likely native panic)`,
+  };
 }
 
 /**
@@ -212,3 +216,27 @@ async function pathExists(p: string): Promise<boolean> {
     return false;
   }
 }
+
+function firstLine(s: string): string {
+  const trimmed = s.trim();
+  const nl = trimmed.indexOf("\n");
+  return nl === -1 ? trimmed : trimmed.slice(0, nl);
+}
+
+/**
+ * Send signal 0 to test whether `pid` corresponds to a live process. Returns
+ * false on ESRCH (no such process) and on any other error (including EPERM,
+ * which we conservatively treat as "not ours, not relevant"). Used by the
+ * doctor's safety gate to distinguish workers actually running from rows
+ * that say `status = 'running'` because the worker crashed before flipping
+ * its row to `stopped` or `dead`.
+ */
+export function isPidAlive(pid: number): boolean {
+  if (!pid || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/worker/llm.ts

@@ -11,12 +11,17 @@ import { getTask, type Task } from "../db/tasks.ts";
 import { logInteraction } from "../db/threads.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import { getTool, type ToolContext, toAnthropicTools } from "../tools/tool.ts";
+import { logger } from "../utils/logger.ts";
 import { fitToContextWindow, getMaxInputTokens } from "./context.ts";
 import { clearLargeResults, maybeStoreResult } from "./large-results.ts";
 import { createLlmClient } from "./llm-client.ts";
 
 registerAllTools();
 
+function truncate(s: string, max: number): string {
+  return s.length > max ? `${s.slice(0, max)}…` : s;
+}
+
 export interface WorkerStreamCallbacks {
   onToken: (text: string) => void;
   onToolStart: (name: string, input: string) => void;
@@ -153,6 +158,9 @@ export async function runAgentLoop(input: {
             tokenCount,
           }),
         );
+        if (!callbacks) {
+          logger.phase("assistant", block.text);
+        }
       }
     }
 
@@ -175,6 +183,12 @@ export async function runAgentLoop(input: {
     for (const toolUse of toolUseBlocks) {
       const toolInput = JSON.stringify(toolUse.input);
       callbacks?.onToolStart(toolUse.name, toolInput);
+      if (!callbacks) {
+        logger.phase(
+          "tool-call",
+          `${toolUse.name} ${truncate(toolInput, 200)}`,
+        );
+      }
       await withDb(dbPath, (conn) =>
         logInteraction(conn, threadId, {
           role: "assistant",
@@ -222,6 +236,11 @@ export async function runAgentLoop(input: {
           durationMs,
         }),
       );
+      if (!callbacks) {
+        const seconds = (durationMs / 1000).toFixed(1);
+        const status = result.isError ? "err" : "ok";
+        logger.phase("tool-result", `${toolUse.name} ${status} in ${seconds}s`);
+      }
 
       if (result.terminal && result.agentResult) {
         return result.agentResult;

package/src/worker/tick.ts

@@ -133,6 +133,9 @@ async function runClaimedTask(opts: {
   const { projectDir, dbPath, config, mcpxClient, callbacks, task } = opts;
 
   logger.info(`Claimed task: ${task.name} (${task.id})`);
+  if (!callbacks && task.description) {
+    logger.dim(task.description);
+  }
   callbacks?.onTaskStart(task);
 
   const threadId = await withDb(dbPath, (conn) =>