botholomew 0.9.9 → 0.9.10

package/README.md

@@ -121,7 +121,8 @@ my-project/
     skills/               # user-defined slash commands
       summarize.md
       standup.md
-    worker.log            # stdout/stderr from spawned workers
+    logs/                 # per-worker log files (one file per spawned worker)
+      <worker-id>.log
 ```
 
 Everything the agent can touch is here. No surprises.

package/package.json

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

package/src/chat/agent.ts

@@ -24,6 +24,7 @@ import {
   buildMetaHeader,
   extractKeywords,
   loadPersistentContext,
+  STYLE_RULES,
 } from "../worker/prompt.ts";
 
 registerAllTools();
@@ -58,6 +59,7 @@ const CHAT_TOOL_NAMES = new Set([
   "skill_write",
   "skill_edit",
   "skill_search",
+  "skill_delete",
 ]);
 
 export function getChatTools() {
@@ -114,7 +116,7 @@ You do NOT execute long-running work directly — enqueue tasks for a background
 Use the available tools to look up tasks, threads, schedules, and context when the user asks about them. Context items live under a drive (disk / url / agent / google-docs / github / …); use \`context_list_drives\` to discover which drives have content, then \`context_tree\`, \`context_info\`, \`context_search\`, or \`context_refresh\` as needed.
 When multiple tool calls are independent of each other (i.e., one does not depend on the result of another), call them all in a single response. They will be executed in parallel, which is faster than calling them one at a time.
 You can update the agent's beliefs and goals files when the user asks you to.
-You can author and refine slash-command skills (reusable prompt templates stored in \`.botholomew/skills/\`) via \`skill_list\`, \`skill_search\`, \`skill_read\`, \`skill_write\`, and \`skill_edit\`. New or edited skills are usable as \`/<name>\` on the user's next message.
+You can author and refine slash-command skills (reusable prompt templates stored in \`.botholomew/skills/\`) via \`skill_list\`, \`skill_search\`, \`skill_read\`, \`skill_write\`, \`skill_edit\`, and \`skill_delete\`. New or edited skills are usable as \`/<name>\` on the user's next message.
 Format your responses using Markdown. Use headings, bold, italic, lists, and code blocks to make your responses clear and well-structured.
 `;
 
@@ -151,6 +153,8 @@ Skip step 2 only if you already called \`mcp_info\` for that exact server+tool e
 `;
   }
 
+  prompt += `\n${STYLE_RULES}`;
+
   return prompt;
 }
 

package/src/commands/skill.ts

@@ -129,6 +129,27 @@ or $1, $2, etc. for positional arguments.
       await Bun.write(filePath, template);
       logger.success(`Created skill: ${filePath}`);
     });
+
+  skill
+    .command("delete <name>")
+    .description("Delete a skill file")
+    .action(async (name: string) => {
+      const dir = program.opts().dir;
+      const skills = await loadSkills(dir);
+      const s = skills.get(name.toLowerCase());
+
+      if (!s) {
+        logger.error(`Skill not found: ${name}`);
+        if (skills.size > 0) {
+          const available = [...skills.keys()].sort().join(", ");
+          console.error(ansis.dim(`Available: ${available}`));
+        }
+        process.exit(1);
+      }
+
+      await Bun.file(s.filePath).delete();
+      logger.success(`Deleted skill: ${s.filePath}`);
+    });
 }
 
 async function validateSingleFile(filePath: string): Promise<void> {

package/src/constants.ts

@@ -13,14 +13,13 @@ export const DEFAULTS = {
   UPDATE_CHECK_TIMEOUT_MS: 5_000,
 } as const;
 export const DB_FILENAME = "data.duckdb";
-export const LOG_FILENAME = "worker.log";
+export const LOGS_DIR = "logs";
 export const CONFIG_FILENAME = "config.json";
 export const MCPX_DIR = "mcpx";
 export const SKILLS_DIR = "skills";
 export const MCPX_SERVERS_FILENAME = "servers.json";
 export const EMBEDDING_DIMENSION = 1536;
 export const EMBEDDING_MODEL = "text-embedding-3-small";
-export const LOG_MAX_BYTES = 10 * 1024 * 1024; // 10 MB
 
 export function getBotholomewDir(projectDir: string): string {
   return join(projectDir, BOTHOLOMEW_DIR);
@@ -30,8 +29,12 @@ export function getDbPath(projectDir: string): string {
   return join(projectDir, BOTHOLOMEW_DIR, DB_FILENAME);
 }
 
-export function getLogPath(projectDir: string): string {
-  return join(projectDir, BOTHOLOMEW_DIR, LOG_FILENAME);
+export function getWorkerLogsDir(projectDir: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, LOGS_DIR);
+}
+
+export function getWorkerLogPath(projectDir: string, workerId: string): string {
+  return join(projectDir, BOTHOLOMEW_DIR, LOGS_DIR, `${workerId}.log`);
 }
 
 export function getConfigPath(projectDir: string): string {

package/src/db/sql/17-worker_log_path.sql

@@ -0,0 +1,3 @@
+-- Per-worker log file path. NULL for foreground / in-process workers that
+-- write to stdout instead of a dedicated file.
+ALTER TABLE workers ADD COLUMN log_path TEXT;

package/src/db/workers.ts

@@ -14,6 +14,7 @@ export interface Worker {
   started_at: Date;
   last_heartbeat_at: Date;
   stopped_at: Date | null;
+  log_path: string | null;
 }
 
 interface WorkerRow {
@@ -26,6 +27,7 @@ interface WorkerRow {
   started_at: string;
   last_heartbeat_at: string;
   stopped_at: string | null;
+  log_path: string | null;
 }
 
 function rowToWorker(row: WorkerRow): Worker {
@@ -39,6 +41,7 @@ function rowToWorker(row: WorkerRow): Worker {
     started_at: new Date(row.started_at),
     last_heartbeat_at: new Date(row.last_heartbeat_at),
     stopped_at: row.stopped_at ? new Date(row.stopped_at) : null,
+    log_path: row.log_path,
   };
 }
 
@@ -50,17 +53,19 @@ export async function registerWorker(
     hostname: string;
     mode: Worker["mode"];
     taskId?: string | null;
+    logPath?: string | null;
   },
 ): Promise<Worker> {
   const row = await db.queryGet<WorkerRow>(
-    `INSERT INTO workers (id, pid, hostname, mode, task_id, status)
-     VALUES (?1, ?2, ?3, ?4, ?5, 'running')
+    `INSERT INTO workers (id, pid, hostname, mode, task_id, status, log_path)
+     VALUES (?1, ?2, ?3, ?4, ?5, 'running', ?6)
      RETURNING *`,
     params.id,
     params.pid,
     params.hostname,
     params.mode,
     params.taskId ?? null,
+    params.logPath ?? null,
   );
   if (!row) throw new Error("INSERT did not return a row");
   return rowToWorker(row);

package/src/init/templates.ts

@@ -8,6 +8,8 @@ agent-modification: false
 You are Botholomew, an AI agent for knowledge work, personified by a wise owl. You help humans manage information, research topics, organize knowledge, and complete intellectual tasks.
 
 You are thoughtful, thorough, and proactive. You work through your task queue methodically, prioritizing appropriately and asking for clarification when needed.
+
+You are direct: lead with the answer, skip preambles, disagree when you have reason to, and never flatter.
 `;
 
 export const BELIEFS_MD = `---

package/src/skills/commands.ts

@@ -1,5 +1,5 @@
 import type { SkillDefinition } from "./parser.ts";
-import { renderSkill } from "./parser.ts";
+import { renderSkill, validateSkillArgs } from "./parser.ts";
 
 export interface SlashCommand {
   name: string;
@@ -14,14 +14,32 @@ export const BUILTIN_SLASH_COMMANDS: SlashCommand[] = [
   { name: "exit", description: "End the chat session" },
 ];
 
+export interface QueueUserMessageOptions {
+  display?: string;
+}
+
 export interface SlashCommandContext {
   skills: Map<string, SkillDefinition>;
   addSystemMessage: (content: string) => void;
-  queueUserMessage: (content: string) => void;
+  queueUserMessage: (content: string, opts?: QueueUserMessageOptions) => void;
   exit: () => void;
   clearChat?: () => void;
 }
 
+export function formatSkillUsage(skill: SkillDefinition): string {
+  const parts = [`/${skill.name}`];
+  for (const arg of skill.arguments) {
+    if (arg.required && arg.default === undefined) {
+      parts.push(`<${arg.name}>`);
+    } else if (arg.default !== undefined) {
+      parts.push(`[${arg.name}=${arg.default}]`);
+    } else {
+      parts.push(`[${arg.name}]`);
+    }
+  }
+  return parts.join(" ");
+}
+
 /**
  * Handle a slash-command input. Returns true if the command was consumed
  * (recognized or errored), false if it should fall through.
@@ -70,9 +88,16 @@ export function handleSlashCommand(
   // Skill dispatch
   const skill = ctx.skills.get(name);
   if (skill) {
+    const { missing } = validateSkillArgs(skill, rawArgs);
+    if (missing.length > 0) {
+      ctx.addSystemMessage(
+        `/${skill.name}: missing required argument(s): ${missing.join(", ")}\n` +
+          `Usage: ${formatSkillUsage(skill)}`,
+      );
+      return true;
+    }
     const rendered = renderSkill(skill, rawArgs);
-    ctx.addSystemMessage(`Running skill: ${skill.name}`);
-    ctx.queueUserMessage(rendered);
+    ctx.queueUserMessage(rendered, { display: input });
     return true;
   }
 

package/src/skills/parser.ts

@@ -55,7 +55,7 @@ export function parseSkillFile(raw: string, filePath: string): SkillDefinition {
  * Split a raw argument string into positional tokens,
  * respecting double-quoted strings.
  */
-function tokenize(raw: string): string[] {
+export function tokenize(raw: string): string[] {
   const tokens: string[] = [];
   let current = "";
   let inQuote = false;
@@ -77,10 +77,30 @@ function tokenize(raw: string): string[] {
   return tokens;
 }
 
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
   const tokens = tokenize(rawArgs);
   let result = skill.body;
 
+  // Replace $<argName> placeholders first, longest names first so a `$start`
+  // arg can't truncate `$start_date`. Word-boundary tail prevents `$end`
+  // from clipping `$endpoint`.
+  const namedArgs = skill.arguments
+    .map((argDef, i) => ({
+      name: argDef.name,
+      value: tokens[i] ?? argDef.default ?? "",
+    }))
+    .filter((a) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(a.name))
+    .sort((a, b) => b.name.length - a.name.length);
+
+  for (const { name, value } of namedArgs) {
+    const re = new RegExp(`\\$${escapeRegex(name)}(?![A-Za-z0-9_])`, "g");
+    result = result.replace(re, value);
+  }
+
   result = result.replaceAll("$ARGUMENTS", rawArgs);
 
   // Replace $1-$9 with positional args or defaults
@@ -93,3 +113,23 @@ export function renderSkill(skill: SkillDefinition, rawArgs: string): string {
 
   return result;
 }
+
+/**
+ * Identify required arguments that have neither a positional token
+ * nor a declared default. Used by the TUI to reject incomplete
+ * slash-command invocations before sending to the LLM.
+ */
+export function validateSkillArgs(
+  skill: SkillDefinition,
+  rawArgs: string,
+): { missing: string[] } {
+  const tokens = tokenize(rawArgs);
+  const missing: string[] = [];
+  skill.arguments.forEach((argDef, i) => {
+    if (!argDef.required) return;
+    const hasToken = tokens[i] !== undefined;
+    const hasDefault = argDef.default !== undefined;
+    if (!hasToken && !hasDefault) missing.push(argDef.name);
+  });
+  return { missing };
+}

package/src/tools/registry.ts

@@ -33,6 +33,7 @@ import { listSchedulesTool } from "./schedule/list.ts";
 import { searchGrepTool } from "./search/grep.ts";
 import { searchSemanticTool } from "./search/semantic.ts";
 // Skill tools
+import { skillDeleteTool } from "./skill/delete.ts";
 import { skillEditTool } from "./skill/edit.ts";
 import { skillListTool } from "./skill/list.ts";
 import { skillReadTool } from "./skill/read.ts";
@@ -102,6 +103,7 @@ export function registerAllTools(): void {
   registerTool(skillWriteTool);
   registerTool(skillEditTool);
   registerTool(skillSearchTool);
+  registerTool(skillDeleteTool);
 
   // Thread
   registerTool(listThreadsTool);

package/src/tools/skill/delete.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { loadSkills } from "../../skills/loader.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  name: z.string().describe("Skill name (case-insensitive)"),
+});
+
+const outputSchema = z.object({
+  name: z.string().nullable(),
+  path: z.string().nullable(),
+  deleted: z.boolean(),
+  is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
+});
+
+export const skillDeleteTool = {
+  name: "skill_delete",
+  description:
+    "[[ bash equivalent command: rm ]] Delete a skill file (user-defined slash command) by name. The file is removed from .botholomew/skills/. Returns a not_found error with the list of available names when the skill doesn't exist.",
+  group: "skill",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const skills = await loadSkills(ctx.projectDir);
+    const skill = skills.get(input.name.toLowerCase());
+
+    if (!skill) {
+      const available = [...skills.keys()].sort();
+      const hint =
+        available.length > 0
+          ? `Available: ${available.join(", ")}. Use skill_list to browse.`
+          : "No skills exist yet. Use skill_write to create one.";
+      return {
+        name: input.name,
+        path: null,
+        deleted: false,
+        is_error: true,
+        error_type: "not_found",
+        message: `Skill not found: ${input.name}`,
+        next_action_hint: hint,
+      };
+    }
+
+    await Bun.file(skill.filePath).delete();
+
+    return {
+      name: skill.name,
+      path: skill.filePath,
+      deleted: true,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tui/App.tsx

@@ -145,13 +145,13 @@ export function App({
   const [activeTab, setActiveTab] = useState<TabId>(1);
   const [workerRunning, setWorkerRunning] = useState(false);
   const [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
-  const queueRef = useRef<string[]>([]);
+  const queueRef = useRef<Array<{ display: string; content: string }>>([]);
   const processingRef = useRef(false);
   const [queuedMessages, setQueuedMessages] = useState<string[]>([]);
   const [selectedQueueIndex, setSelectedQueueIndex] = useState(0);
 
   const syncQueue = useCallback(() => {
-    const snapshot = [...queueRef.current];
+    const snapshot = queueRef.current.map((e) => e.display);
     setQueuedMessages(snapshot);
     setSelectedQueueIndex((prev) =>
       snapshot.length === 0 ? 0 : Math.min(prev, snapshot.length - 1),
@@ -297,7 +297,7 @@ export function App({
           );
           syncQueue();
           if (msg) {
-            setInputValue(msg);
+            setInputValue(msg.display);
           }
           return;
         }
@@ -327,9 +327,9 @@ export function App({
     processingRef.current = true;
 
     while (queueRef.current.length > 0) {
-      const trimmed = queueRef.current.shift();
+      const entry = queueRef.current.shift();
       syncQueue();
-      if (!trimmed) break;
+      if (!entry) break;
       setIsLoading(true);
       setStreamingText("");
       setActiveToolCalls([]);
@@ -338,7 +338,7 @@ export function App({
       const userMsg: ChatMessage = {
         id: msgId(),
         role: "user",
-        content: trimmed,
+        content: entry.display,
         timestamp: new Date(),
       };
       setMessages((prev) => [...prev, userMsg]);
@@ -366,7 +366,7 @@ export function App({
 
       let lastStreamFlush = 0;
       try {
-        await sendMessage(sessionRef.current, trimmed, {
+        await sendMessage(sessionRef.current, entry.content, {
           onToken: (token) => {
             currentText += token;
             const now = Date.now();
@@ -432,7 +432,10 @@ export function App({
   useEffect(() => {
     if (ready && initialPrompt && !initialPromptSent.current) {
       initialPromptSent.current = true;
-      queueRef.current.push(initialPrompt);
+      queueRef.current.push({
+        display: initialPrompt,
+        content: initialPrompt,
+      });
       syncQueue();
       setInputHistory((prev) => [...prev, initialPrompt]);
       processQueue();
@@ -570,9 +573,12 @@ export function App({
             };
             setMessages((prev) => [...prev, msg]);
           },
-          queueUserMessage: (content) => {
+          queueUserMessage: (content, opts) => {
             setInputHistory((prev) => [...prev, trimmed]);
-            queueRef.current.push(content);
+            queueRef.current.push({
+              display: opts?.display ?? content,
+              content,
+            });
             syncQueue();
             processQueue();
           },
@@ -618,7 +624,7 @@ export function App({
       }
 
       setInputHistory((prev) => [...prev, trimmed]);
-      queueRef.current.push(trimmed);
+      queueRef.current.push({ display: trimmed, content: trimmed });
       syncQueue();
       processQueue();
     },

package/src/tui/components/WorkerPanel.tsx

@@ -1,7 +1,8 @@
 import { Box, Text, useInput, useStdout } from "ink";
-import { memo, useEffect, useState } from "react";
+import { memo, useEffect, useMemo, useState } from "react";
 import { withDb } from "../../db/connection.ts";
 import { listWorkers, type Worker } from "../../db/workers.ts";
+import { readLogTail } from "../../worker/log-reader.ts";
 
 interface WorkerPanelProps {
   dbPath: string;
@@ -15,6 +16,9 @@ const STATUS_FILTERS: readonly (Worker["status"] | null)[] = [
   "dead",
 ];
 
+const PAGE_SCROLL_LINES = 10;
+const LOG_POLL_MS = 1500;
+
 function statusColor(status: Worker["status"]): string {
   switch (status) {
     case "running":
@@ -36,6 +40,12 @@ function formatAge(from: Date, now: Date): string {
   return `${Math.floor(hours / 24)}d`;
 }
 
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+
 export const WorkerPanel = memo(function WorkerPanel({
   dbPath,
   isActive,
@@ -46,6 +56,12 @@ export const WorkerPanel = memo(function WorkerPanel({
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [filterIdx, setFilterIdx] = useState(0);
   const [now, setNow] = useState(() => new Date());
+  const [viewMode, setViewMode] = useState<"detail" | "log">("detail");
+  const [logContent, setLogContent] = useState("");
+  const [logSize, setLogSize] = useState(0);
+  const [logTruncated, setLogTruncated] = useState(false);
+  const [logScroll, setLogScroll] = useState(0);
+  const [logFollow, setLogFollow] = useState(true);
 
   useEffect(() => {
     let mounted = true;
@@ -72,17 +88,135 @@ export const WorkerPanel = memo(function WorkerPanel({
     };
   }, [dbPath, filterIdx]);
 
+  const selected = workers[selectedIndex];
+  const selectedLogPath = selected?.log_path ?? null;
+
+  useEffect(() => {
+    if (viewMode !== "log" || !selectedLogPath) return;
+    let mounted = true;
+
+    const refresh = async () => {
+      try {
+        const tail = await readLogTail(selectedLogPath);
+        if (!mounted) return;
+        setLogContent(tail.content);
+        setLogSize(tail.size);
+        setLogTruncated(tail.truncated);
+      } catch {
+        // Ignore transient read errors; next tick will retry.
+      }
+    };
+
+    refresh();
+    const interval = setInterval(refresh, LOG_POLL_MS);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [viewMode, selectedLogPath]);
+
+  // Reset log scroll + content when the selection or view mode changes.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: intentional reset triggers
+  useEffect(() => {
+    setLogScroll(0);
+    setLogFollow(true);
+    setLogContent("");
+    setLogSize(0);
+    setLogTruncated(false);
+  }, [selected?.id, viewMode]);
+
+  const logLines = useMemo(() => {
+    if (logContent.length === 0) return [];
+    // Trim a single trailing newline so the rendered list doesn't end with a
+    // blank row, but preserve internal blank lines.
+    const trimmed = logContent.endsWith("\n")
+      ? logContent.slice(0, -1)
+      : logContent;
+    return trimmed.split("\n");
+  }, [logContent]);
+
+  const visibleRows = Math.max(4, termRows - 8);
+  const maxLogScroll = Math.max(0, logLines.length - visibleRows);
+
+  // When following, snap scroll to the bottom whenever new log content
+  // arrives. The user can break follow mode by scrolling up; pressing G or
+  // running off the end via j/J resumes it.
+  useEffect(() => {
+    if (viewMode === "log" && logFollow) {
+      setLogScroll(maxLogScroll);
+    }
+  }, [viewMode, logFollow, maxLogScroll]);
+
   useInput(
     (input, key) => {
       if (!isActive) return;
+
+      if (input === "l") {
+        setViewMode((m) => (m === "log" ? "detail" : "log"));
+        return;
+      }
+
       if (key.upArrow) {
+        if (viewMode === "log" && key.shift) {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - 1));
+          return;
+        }
         setSelectedIndex((i) => Math.max(0, i - 1));
         return;
       }
       if (key.downArrow) {
+        if (viewMode === "log" && key.shift) {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + 1);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
         setSelectedIndex((i) => Math.min(workers.length - 1, i + 1));
         return;
       }
+
+      if (viewMode === "log") {
+        if (input === "j") {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + 1);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
+        if (input === "k") {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - 1));
+          return;
+        }
+        if (input === "J") {
+          setLogScroll((s) => {
+            const next = Math.min(maxLogScroll, s + PAGE_SCROLL_LINES);
+            if (next >= maxLogScroll) setLogFollow(true);
+            return next;
+          });
+          return;
+        }
+        if (input === "K") {
+          setLogFollow(false);
+          setLogScroll((s) => Math.max(0, s - PAGE_SCROLL_LINES));
+          return;
+        }
+        if (input === "g") {
+          setLogFollow(false);
+          setLogScroll(0);
+          return;
+        }
+        if (input === "G") {
+          setLogFollow(true);
+          setLogScroll(maxLogScroll);
+          return;
+        }
+      }
+
       if (input === "f") {
         setFilterIdx((i) => (i + 1) % STATUS_FILTERS.length);
         return;
@@ -91,9 +225,8 @@ export const WorkerPanel = memo(function WorkerPanel({
     { isActive },
   );
 
-  const selected = workers[selectedIndex];
   const filterLabel = STATUS_FILTERS[filterIdx] ?? "all";
-  const visibleRows = Math.max(4, termRows - 10);
+  const visibleSidebarRows = Math.max(4, termRows - 10);
 
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={1}>
@@ -103,7 +236,11 @@ export const WorkerPanel = memo(function WorkerPanel({
         </Text>
         <Text dimColor> · filter: </Text>
         <Text color="yellow">{filterLabel}</Text>
-        <Text dimColor>{" · [f] cycle filter  [↑↓] select"}</Text>
+        <Text dimColor>
+          {viewMode === "log"
+            ? "  · [l] back  [↑↓] select  [j/k] scroll  [g/G] top/bot  [f] filter"
+            : "  · [l] view log  [f] cycle filter  [↑↓] select"}
+        </Text>
       </Box>
 
       {workers.length === 0 ? (
@@ -121,7 +258,7 @@ export const WorkerPanel = memo(function WorkerPanel({
             marginRight={2}
             overflow="hidden"
           >
-            {workers.slice(0, visibleRows).map((w, i) => {
+            {workers.slice(0, visibleSidebarRows).map((w, i) => {
               const active = i === selectedIndex;
               const short = w.id.slice(0, 8);
               return (
@@ -148,7 +285,21 @@ export const WorkerPanel = memo(function WorkerPanel({
             })}
           </Box>
           <Box flexDirection="column" flexGrow={1}>
-            {selected ? <WorkerDetail worker={selected} now={now} /> : null}
+            {selected ? (
+              viewMode === "log" ? (
+                <WorkerLogView
+                  worker={selected}
+                  lines={logLines}
+                  scroll={logScroll}
+                  visibleRows={visibleRows}
+                  truncated={logTruncated}
+                  size={logSize}
+                  follow={logFollow}
+                />
+              ) : (
+                <WorkerDetail worker={selected} now={now} />
+              )
+            ) : null}
           </Box>
         </Box>
       )}
@@ -201,6 +352,89 @@ function WorkerDetail({ worker, now }: { worker: Worker; now: Date }) {
             {worker.task_id}
           </Text>
         )}
+        {worker.log_path && (
+          <Text>
+            <Text dimColor>Log </Text>
+            <Text dimColor>{worker.log_path}</Text>
+          </Text>
+        )}
+      </Box>
+    </Box>
+  );
+}
+
+function WorkerLogView({
+  worker,
+  lines,
+  scroll,
+  visibleRows,
+  truncated,
+  size,
+  follow,
+}: {
+  worker: Worker;
+  lines: string[];
+  scroll: number;
+  visibleRows: number;
+  truncated: boolean;
+  size: number;
+  follow: boolean;
+}) {
+  if (!worker.log_path) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="blue">
+          {worker.id}
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>
+            No log file (worker is running in foreground or was started before
+            per-worker logs existed).
+          </Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  if (lines.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="blue">
+          {worker.id}
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>Log empty.</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  const visible = lines.slice(scroll, scroll + visibleRows);
+  const lastLine = Math.min(scroll + visibleRows, lines.length);
+
+  return (
+    <Box flexDirection="column" flexGrow={1}>
+      <Box>
+        <Text bold color="blue">
+          {worker.id.slice(0, 8)}
+        </Text>
+        <Text dimColor>
+          {" "}
+          · {formatBytes(size)}
+          {truncated ? " (tail only)" : ""} ·{" "}
+        </Text>
+        <Text color={follow ? "green" : "yellow"}>
+          {follow ? "following" : "paused"}
+        </Text>
+        <Text dimColor>
+          {"  "}[{scroll + 1}–{lastLine} of {lines.length}]
+        </Text>
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {visible.map((line, i) => {
+          const lineNum = scroll + i;
+          return <Text key={lineNum}>{line || " "}</Text>;
+        })}
       </Box>
     </Box>
   );

package/src/worker/index.ts

@@ -24,6 +24,19 @@ export interface StartWorkerOptions {
    * When omitted, the worker claims the next eligible task from the queue.
    */
   taskId?: string;
+  /**
+   * Pre-allocated worker id from the spawn parent. When provided, the parent
+   * has already opened a per-worker log file at this id and we record both on
+   * the workers row. Foreground/in-process callers may omit this and a fresh
+   * id will be generated.
+   */
+  workerId?: string;
+  /**
+   * Path to the per-worker log file (set by the spawn parent when launching
+   * a detached worker). Stored on the workers row so the TUI can tail it.
+   * Null/undefined for foreground workers writing to stdout.
+   */
+  logPath?: string;
   /**
    * Whether to evaluate schedules as part of this run.
    * Defaults to `true` for one-shot workers without a taskId and for persist
@@ -86,7 +99,7 @@ export async function startWorker(
     logger.info("MCPX client initialized with external tools");
   }
 
-  const workerId = uuidv7();
+  const workerId = options.workerId ?? uuidv7();
   await withDb(dbPath, (conn) =>
     registerWorker(conn, {
       id: workerId,
@@ -94,6 +107,7 @@ export async function startWorker(
       hostname: hostname(),
       mode,
       taskId: taskId ?? null,
+      logPath: options.logPath ?? null,
     }),
   );
 

package/src/worker/log-reader.ts

@@ -0,0 +1,35 @@
+export const DEFAULT_LOG_TAIL_BYTES = 128 * 1024;
+
+export interface LogTail {
+  content: string;
+  truncated: boolean;
+  size: number;
+}
+
+/**
+ * Read the tail of a worker log file. Returns at most `maxBytes` from the end
+ * of the file; sets `truncated` when the file is larger than that.
+ *
+ * If the file doesn't exist (worker hasn't written anything yet), returns
+ * empty content rather than throwing — the caller renders an empty-state
+ * message instead of an error.
+ */
+export async function readLogTail(
+  logPath: string,
+  maxBytes = DEFAULT_LOG_TAIL_BYTES,
+): Promise<LogTail> {
+  const file = Bun.file(logPath);
+  if (!(await file.exists())) {
+    return { content: "", truncated: false, size: 0 };
+  }
+  const size = file.size;
+  if (size === 0) {
+    return { content: "", truncated: false, size: 0 };
+  }
+  if (size <= maxBytes) {
+    return { content: await file.text(), truncated: false, size };
+  }
+  const start = size - maxBytes;
+  const content = await file.slice(start, size).text();
+  return { content, truncated: true, size };
+}

package/src/worker/prompt.ts

@@ -13,6 +13,14 @@ const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
 ).json();
 
+export const STYLE_RULES = `## Style
+- Open with the result, action, or next step. Skip preambles like "Great question", "You're absolutely right", "Let me…", "I'll go ahead and…".
+- Don't flatter the user or their ideas. If a request is wrong, ambiguous, or risky, say so plainly with the reason.
+- Hold your position when you have one. Don't capitulate to pushback that brings no new evidence.
+- Be terse. Don't restate what you just did or are about to do — show it.
+- Report failures and uncertainty directly. Don't paper over gaps with confident prose.
+`;
+
 /**
  * Extract keyword set from free-form text: lowercase, split on whitespace,
  * keep words longer than 3 chars. Used to match `loading: contextual` files
@@ -160,5 +168,7 @@ Skip step 2 only if you already called \`mcp_info\` for that exact server+tool e
 `;
   }
 
+  prompt += `\n${STYLE_RULES}`;
+
   return prompt;
 }

package/src/worker/run.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env bun
 
 // Standalone entry point for a worker when spawned as a detached process.
-// Usage: bun run src/worker/run.ts <projectDir> [--persist] [--task-id=<uuid>] [--no-eval-schedules]
+// Usage: bun run src/worker/run.ts <projectDir> [--worker-id=<uuid>] [--log-path=<path>] [--persist] [--task-id=<uuid>] [--no-eval-schedules]
 
 import { startWorker } from "./index.ts";
 
 const projectDir = process.argv[2];
 if (!projectDir) {
   console.error(
-    "Usage: bun run src/worker/run.ts <projectDir> [--persist] [--task-id=<uuid>] [--no-eval-schedules]",
+    "Usage: bun run src/worker/run.ts <projectDir> [--worker-id=<uuid>] [--log-path=<path>] [--persist] [--task-id=<uuid>] [--no-eval-schedules]",
   );
   process.exit(1);
 }
@@ -18,9 +18,17 @@ const persist = args.includes("--persist");
 const noEvalSchedules = args.includes("--no-eval-schedules");
 const taskIdArg = args.find((a) => a.startsWith("--task-id="));
 const taskId = taskIdArg ? taskIdArg.slice("--task-id=".length) : undefined;
+const workerIdArg = args.find((a) => a.startsWith("--worker-id="));
+const workerId = workerIdArg
+  ? workerIdArg.slice("--worker-id=".length)
+  : undefined;
+const logPathArg = args.find((a) => a.startsWith("--log-path="));
+const logPath = logPathArg ? logPathArg.slice("--log-path=".length) : undefined;
 
 await startWorker(projectDir, {
   mode: persist ? "persist" : "once",
   taskId,
+  workerId,
+  logPath,
   evalSchedules: noEvalSchedules ? false : undefined,
 });

package/src/worker/spawn.ts

@@ -1,5 +1,11 @@
+import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { getBotholomewDir, getLogPath } from "../constants.ts";
+import {
+  getBotholomewDir,
+  getWorkerLogPath,
+  getWorkerLogsDir,
+} from "../constants.ts";
+import { uuidv7 } from "../db/uuid.ts";
 import { logger } from "../utils/logger.ts";
 import type { WorkerMode } from "./index.ts";
 
@@ -12,11 +18,14 @@ export interface SpawnWorkerOptions {
  * Spawn a worker as a detached background process. Unlike the old daemon
  * model, multiple workers per project are allowed and expected — this just
  * launches a new one.
+ *
+ * The parent generates the worker id and opens a per-worker log file before
+ * spawning so that the TUI / CLI can later tail just this worker's output.
  */
 export async function spawnWorker(
   projectDir: string,
   options: SpawnWorkerOptions = {},
-): Promise<{ pid: number }> {
+): Promise<{ pid: number; workerId: string; logPath: string }> {
   const dotDir = getBotholomewDir(projectDir);
   const dirExists = await Bun.file(join(dotDir, "config.json")).exists();
   if (!dirExists) {
@@ -24,11 +33,20 @@ export async function spawnWorker(
     process.exit(1);
   }
 
-  const logPath = getLogPath(projectDir);
+  const workerId = uuidv7();
+  await mkdir(getWorkerLogsDir(projectDir), { recursive: true });
+  const logPath = getWorkerLogPath(projectDir, workerId);
   const logFile = Bun.file(logPath);
 
   const workerScript = new URL("./run.ts", import.meta.url).pathname;
-  const args = ["bun", "run", workerScript, projectDir];
+  const args = [
+    "bun",
+    "run",
+    workerScript,
+    projectDir,
+    `--worker-id=${workerId}`,
+    `--log-path=${logPath}`,
+  ];
   if (options.mode === "persist") args.push("--persist");
   if (options.taskId) args.push(`--task-id=${options.taskId}`);
 
@@ -44,5 +62,5 @@ export async function spawnWorker(
   );
   logger.dim(`  Log: ${logPath}`);
 
-  return { pid: proc.pid ?? 0 };
+  return { pid: proc.pid ?? 0, workerId, logPath };
 }