botholomew 0.3.1 → 0.3.2

package/src/tools/task/fail.ts

@@ -7,6 +7,7 @@ const inputSchema = z.object({
 
 const outputSchema = z.object({
   message: z.string(),
+  is_error: z.boolean(),
 });
 
 export const failTaskTool = {
@@ -18,5 +19,6 @@ export const failTaskTool = {
   outputSchema,
   execute: async (input) => ({
     message: `Task failed: ${input.reason}`,
+    is_error: false,
   }),
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/task/list.ts

@@ -20,6 +20,7 @@ const outputSchema = z.object({
     }),
   ),
   count: z.number(),
+  is_error: z.boolean(),
 });
 
 export const listTasksTool = {
@@ -44,6 +45,7 @@ export const listTasksTool = {
         created_at: t.created_at.toISOString(),
       })),
       count: tasks.length,
+      is_error: false,
     };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/task/update.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { getTask, TASK_PRIORITIES, updateTask } from "../../db/tasks.ts";
+import { logger } from "../../utils/logger.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  id: z.string().describe("ID of the task to update"),
+  name: z.string().optional().describe("Updated task name"),
+  description: z.string().optional().describe("Updated task description"),
+  priority: z.enum(TASK_PRIORITIES).optional().describe("Updated priority"),
+  blocked_by: z
+    .array(z.string())
+    .optional()
+    .describe("Replacement list of task IDs that must complete first"),
+});
+
+const outputSchema = z.object({
+  task: z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      description: z.string(),
+      status: z.string(),
+      priority: z.string(),
+      blocked_by: z.array(z.string()),
+      updated_at: z.string(),
+    })
+    .nullable(),
+  message: z.string(),
+  is_error: z.boolean(),
+});
+
+export const updateTaskTool = {
+  name: "update_task",
+  description:
+    "Update a pending task's name, description, priority, or dependencies. Only pending tasks can be updated.",
+  group: "task",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const existing = await getTask(ctx.conn, input.id);
+    if (!existing) {
+      return {
+        task: null,
+        message: `Task ${input.id} not found`,
+        is_error: true,
+      };
+    }
+    if (existing.status !== "pending") {
+      return {
+        task: null,
+        message: `Cannot update task ${input.id}: only pending tasks can be updated (current status: ${existing.status})`,
+        is_error: true,
+      };
+    }
+
+    const updated = await updateTask(ctx.conn, input.id, {
+      name: input.name,
+      description: input.description,
+      priority: input.priority,
+      blocked_by: input.blocked_by,
+    });
+
+    if (!updated) {
+      return {
+        task: null,
+        message: `Failed to update task ${input.id}`,
+        is_error: true,
+      };
+    }
+
+    logger.info(`Updated task: ${updated.name} (${updated.id})`);
+    return {
+      task: {
+        id: updated.id,
+        name: updated.name,
+        description: updated.description,
+        status: updated.status,
+        priority: updated.priority,
+        blocked_by: updated.blocked_by,
+        updated_at: updated.updated_at.toISOString(),
+      },
+      message: `Updated task "${updated.name}"`,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/task/view.ts

@@ -22,6 +22,7 @@ const outputSchema = z.object({
       updated_at: z.string(),
     })
     .nullable(),
+  is_error: z.boolean(),
 });
 
 export const viewTaskTool = {
@@ -32,7 +33,7 @@ export const viewTaskTool = {
   outputSchema,
   execute: async (input, ctx) => {
     const task = await getTask(ctx.conn, input.id);
-    if (!task) return { task: null };
+    if (!task) return { task: null, is_error: true };
     return {
       task: {
         id: task.id,
@@ -47,6 +48,7 @@ export const viewTaskTool = {
         created_at: task.created_at.toISOString(),
         updated_at: task.updated_at.toISOString(),
       },
+      is_error: false,
     };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/task/wait.ts

@@ -7,6 +7,7 @@ const inputSchema = z.object({
 
 const outputSchema = z.object({
   message: z.string(),
+  is_error: z.boolean(),
 });
 
 export const waitTaskTool = {
@@ -19,5 +20,6 @@ export const waitTaskTool = {
   outputSchema,
   execute: async (input) => ({
     message: `Task waiting: ${input.reason}`,
+    is_error: false,
   }),
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/thread/list.ts

@@ -22,6 +22,7 @@ const outputSchema = z.object({
     }),
   ),
   count: z.number(),
+  is_error: z.boolean(),
 });
 
 export const listThreadsTool = {
@@ -45,6 +46,7 @@ export const listThreadsTool = {
         ended_at: t.ended_at?.toISOString() ?? null,
       })),
       count: threads.length,
+      is_error: false,
     };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/thread/view.ts

@@ -28,6 +28,7 @@ const outputSchema = z.object({
       created_at: z.string(),
     }),
   ),
+  is_error: z.boolean(),
 });
 
 export const viewThreadTool = {
@@ -39,7 +40,7 @@ export const viewThreadTool = {
   outputSchema,
   execute: async (input, ctx) => {
     const result = await getThread(ctx.conn, input.id);
-    if (!result) return { thread: null, interactions: [] };
+    if (!result) return { thread: null, interactions: [], is_error: false };
     return {
       thread: {
         id: result.thread.id,
@@ -58,6 +59,7 @@ export const viewThreadTool = {
         tool_name: i.tool_name,
         created_at: i.created_at.toISOString(),
       })),
+      is_error: false,
     };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/tool.ts

@@ -13,9 +13,11 @@ export interface ToolContext {
   embedFn?: EmbedFn;
 }
 
+type ToolOutputBase = { is_error: z.ZodBoolean };
+
 export interface ToolDefinition<
   TInput extends z.ZodObject<z.ZodRawShape>,
-  TOutput extends z.ZodType,
+  TOutput extends z.ZodObject<z.ZodRawShape & ToolOutputBase>,
 > {
   name: string;
   description: string;
@@ -33,14 +35,14 @@ export interface ToolDefinition<
 
 export type AnyToolDefinition = ToolDefinition<
   z.ZodObject<z.ZodRawShape>,
-  z.ZodType
+  z.ZodObject<z.ZodRawShape & ToolOutputBase>
 >;
 
 const tools = new Map<string, AnyToolDefinition>();
 
 export function registerTool<
   TInput extends z.ZodObject<z.ZodRawShape>,
-  TOutput extends z.ZodType,
+  TOutput extends z.ZodObject<z.ZodRawShape & ToolOutputBase>,
 >(tool: ToolDefinition<TInput, TOutput>): void {
   tools.set(tool.name, tool as unknown as AnyToolDefinition);
 }

package/src/tui/App.tsx

@@ -6,10 +6,10 @@ import {
   sendMessage,
   startChatSession,
 } from "../chat/session.ts";
+import { MAX_INLINE_CHARS, PAGE_SIZE_CHARS } from "../daemon/large-results.ts";
 import type { Interaction } from "../db/threads.ts";
 import { getThread } from "../db/threads.ts";
 import { ContextPanel } from "./components/ContextPanel.tsx";
-import { Divider } from "./components/Divider.tsx";
 import { HelpPanel } from "./components/HelpPanel.tsx";
 import { InputBar } from "./components/InputBar.tsx";
 import { AnimatedLogo } from "./components/Logo.tsx";
@@ -17,8 +17,11 @@ import { type ChatMessage, MessageList } from "./components/MessageList.tsx";
 import { QueuePanel } from "./components/QueuePanel.tsx";
 import { StatusBar } from "./components/StatusBar.tsx";
 import { TabBar, type TabId } from "./components/TabBar.tsx";
+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 { ansi } from "./theme.ts";
 
 interface AppProps {
   projectDir: string;
@@ -31,15 +34,28 @@ function msgId(): string {
   return `msg-${++nextMsgId}`;
 }
 
+function detectToolError(output: string | undefined): boolean {
+  if (!output) return false;
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed === "object" && parsed?.is_error === true) return true;
+  } catch {
+    /* not JSON */
+  }
+  return false;
+}
+
 function restoreMessagesFromInteractions(
   interactions: Interaction[],
 ): ChatMessage[] {
   const result: ChatMessage[] = [];
   let pendingTools: ToolCallData[] = [];
 
+  let restoredIdx = 0;
   for (const ix of interactions) {
     if (ix.kind === "tool_use") {
       pendingTools.push({
+        id: `restored-${restoredIdx++}`,
         name: ix.tool_name ?? "unknown",
         input: ix.tool_input ?? "{}",
         running: false,
@@ -49,6 +65,14 @@ function restoreMessagesFromInteractions(
       const tc = pendingTools.find((t) => t.name === ix.tool_name && !t.output);
       if (tc) {
         tc.output = ix.content;
+        tc.isError = detectToolError(ix.content);
+        if (ix.content.length > MAX_INLINE_CHARS) {
+          tc.largeResult = {
+            id: "(restored)",
+            chars: ix.content.length,
+            pages: Math.ceil(ix.content.length / PAGE_SIZE_CHARS),
+          };
+        }
       }
     } else if (ix.kind === "message" && ix.role === "user") {
       result.push({
@@ -95,11 +119,13 @@ export function App({
   const [streamingText, setStreamingText] = useState("");
   const [activeToolCalls, setActiveToolCalls] = useState<ToolCallData[]>([]);
   const [ready, setReady] = useState(false);
-  const [splashDone, setSplashDone] = useState(false);
+  const skipSplash = !!(resumeThreadId || initialPrompt);
+  const [splashDone, setSplashDone] = useState(skipSplash);
   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 [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
   const queueRef = useRef<string[]>([]);
   const processingRef = useRef(false);
   const [queuedMessages, setQueuedMessages] = useState<string[]>([]);
@@ -157,7 +183,7 @@ export function App({
         const threadId = sessionRef.current.threadId;
         endChatSession(sessionRef.current);
         process.stderr.write(
-          `\nThread: ${threadId}\nResume with: \x1b[32mbotholomew chat --thread-id ${threadId}\x1b[0m\n`,
+          `\nThread: ${threadId}\nResume with: ${ansi.success}botholomew chat --thread-id ${threadId}${ansi.reset}\n`,
         );
       }
     };
@@ -169,63 +195,78 @@ export function App({
     return () => clearTimeout(timer);
   }, []);
 
-  // Tab switching via useInput at the App level
-  // On the Chat tab (1), only Tab key switches — number keys go to InputBar.
-  // On other tabs, both Tab and number keys switch tabs, Escape returns to Chat.
-  useInput((input, key) => {
-    // Ctrl+C exits
-    if (input === "c" && key.ctrl) {
-      exit();
-      return;
-    }
-
-    // Tab key cycles tabs — always active (InputBar ignores tab)
-    if (key.tab && !key.shift) {
-      setActiveTab((t) => ((t % 4) + 1) as TabId);
-      return;
-    }
-
-    // Queue manipulation keybindings (only when queue has items on Chat tab)
-    if (activeTab === 1 && queuedMessages.length > 0 && key.ctrl) {
-      if (input === "j") {
-        setSelectedQueueIndex((i) =>
-          Math.min(i + 1, queuedMessages.length - 1),
-        );
-        return;
-      }
-      if (input === "k") {
-        setSelectedQueueIndex((i) => Math.max(i - 1, 0));
+  // Stable ref for App-level input handler — same pattern as InputBar to
+  // prevent Ink's useInput from re-registering stdin listeners on every render.
+  const activeTabRef = useRef(activeTab);
+  const queuedMessagesRef = useRef(queuedMessages);
+  const selectedQueueIndexRef = useRef(selectedQueueIndex);
+  activeTabRef.current = activeTab;
+  queuedMessagesRef.current = queuedMessages;
+  selectedQueueIndexRef.current = selectedQueueIndex;
+
+  const stableAppHandler = useCallback(
+    // biome-ignore lint/suspicious/noExplicitAny: Ink's Key type is not exported
+    (input: string, key: any) => {
+      // Ctrl+C exits
+      if (input === "c" && key.ctrl) {
+        exit();
         return;
       }
-      if (input === "x") {
-        queueRef.current.splice(selectedQueueIndex, 1);
-        syncQueue();
+
+      // Tab key cycles tabs — always active (InputBar ignores tab)
+      if (key.tab && !key.shift) {
+        setActiveTab((t) => ((t % 6) + 1) as TabId);
         return;
       }
-      if (input === "e") {
-        const [msg] = queueRef.current.splice(selectedQueueIndex, 1);
-        syncQueue();
-        if (msg) {
-          setInputValue(msg);
+
+      // Queue manipulation keybindings (only when queue has items on Chat tab)
+      const tab = activeTabRef.current;
+      const queue = queuedMessagesRef.current;
+      if (tab === 1 && queue.length > 0 && key.ctrl) {
+        if (input === "j") {
+          setSelectedQueueIndex((i) => Math.min(i + 1, queue.length - 1));
+          return;
+        }
+        if (input === "k") {
+          setSelectedQueueIndex((i) => Math.max(i - 1, 0));
+          return;
+        }
+        if (input === "x") {
+          queueRef.current.splice(selectedQueueIndexRef.current, 1);
+          syncQueue();
+          return;
+        }
+        if (input === "e") {
+          const [msg] = queueRef.current.splice(
+            selectedQueueIndexRef.current,
+            1,
+          );
+          syncQueue();
+          if (msg) {
+            setInputValue(msg);
+          }
+          return;
         }
-        return;
       }
-    }
 
-    if (activeTab !== 1) {
-      // Number keys jump to tab on non-chat tabs
-      const num = Number.parseInt(input, 10);
-      if (num >= 1 && num <= 4) {
-        setActiveTab(num as TabId);
-        return;
-      }
-      // Escape returns to chat
-      if (key.escape) {
-        setActiveTab(1);
-        return;
+      if (tab !== 1) {
+        // Number keys jump to tab on non-chat tabs
+        const num = Number.parseInt(input, 10);
+        if (num >= 1 && num <= 6) {
+          setActiveTab(num as TabId);
+          return;
+        }
+        // Escape returns to chat
+        if (key.escape) {
+          setActiveTab(1);
+          return;
+        }
       }
-    }
-  });
+    },
+    [exit, syncQueue],
+  );
+
+  useInput(stableAppHandler);
 
   const processQueue = useCallback(async () => {
     if (processingRef.current || !sessionRef.current) return;
@@ -268,17 +309,23 @@ export function App({
         }
       };
 
+      let lastStreamFlush = 0;
       try {
         await sendMessage(sessionRef.current, trimmed, {
           onToken: (token) => {
             currentText += token;
-            setStreamingText(currentText);
+            const now = Date.now();
+            if (now - lastStreamFlush >= 50) {
+              setStreamingText(currentText);
+              lastStreamFlush = now;
+            }
           },
-          onToolStart: (name, input) => {
+          onToolStart: (id, name, input) => {
             if (currentText) {
               finalizeSegment();
             }
             const tc: ToolCallData = {
+              id,
               name,
               input,
               running: true,
@@ -287,13 +334,15 @@ export function App({
             pendingToolCalls.push(tc);
             setActiveToolCalls([...pendingToolCalls]);
           },
-          onToolEnd: (name, output) => {
-            const tc = pendingToolCalls.find(
-              (t) => t.name === name && t.running,
-            );
+          onToolEnd: (id, _name, output, isError, meta) => {
+            const tc = pendingToolCalls.find((t) => t.id === id);
             if (tc) {
               tc.running = false;
               tc.output = output;
+              tc.isError = isError;
+              if (meta?.largeResult) {
+                tc.largeResult = meta.largeResult;
+              }
             }
             setActiveToolCalls([...pendingToolCalls]);
           },
@@ -330,6 +379,28 @@ export function App({
     }
   }, [ready, initialPrompt, processQueue, syncQueue]);
 
+  // Poll for chat thread title updates
+  useEffect(() => {
+    if (!ready || !sessionRef.current) return;
+    let mounted = true;
+
+    const refreshTitle = async () => {
+      const session = sessionRef.current;
+      if (!session) return;
+      const result = await getThread(session.conn, session.threadId);
+      if (mounted && result?.thread.title) {
+        setChatTitle(result.thread.title);
+      }
+    };
+
+    refreshTitle();
+    const interval = setInterval(refreshTitle, 5000);
+    return () => {
+      mounted = false;
+      clearInterval(interval);
+    };
+  }, [ready]);
+
   const handleSubmit = useCallback(
     async (text: string) => {
       const trimmed = text.trim();
@@ -344,14 +415,13 @@ export function App({
           content: [
             "Navigation:",
             "  Tab            Cycle between panels",
-            "  1-4            Jump to panel (when not in Chat)",
+            "  1-6            Jump to panel (when not in Chat)",
             "  Escape         Return to Chat",
             "",
             "Chat (Tab 1):",
             "  Enter          Send message",
             "  ⌥+Enter        Insert newline",
             "  ↑/↓            Browse input history",
-            "  Shift+↑/↓      Scroll chat history",
             "",
             "Tools (Tab 2):",
             "  ↑/↓            Select tool call",
@@ -365,6 +435,22 @@ export function App({
             "  /              Search context",
             "  d              Delete selected item",
             "",
+            "Tasks (Tab 4):",
+            "  ↑/↓            Navigate task list",
+            "  Shift+↑/↓      Scroll detail pane",
+            "  j/k            Scroll detail pane",
+            "  f              Cycle status filter",
+            "  p              Cycle priority filter",
+            "  r              Refresh tasks",
+            "",
+            "Threads (Tab 5):",
+            "  ↑/↓            Navigate thread list",
+            "  Shift+↑/↓      Scroll detail pane",
+            "  j/k            Scroll detail pane",
+            "  f              Cycle type filter",
+            "  d              Delete thread (with confirmation)",
+            "  r              Refresh threads",
+            "",
             "Commands:",
             "  /help           Show this help",
             "  /quit, /exit    End the chat session",
@@ -388,6 +474,20 @@ export function App({
     [exit, processQueue, syncQueue],
   );
 
+  const sessionConn = sessionRef.current?.conn;
+  const inputBarHeader = useMemo(
+    () =>
+      sessionConn ? (
+        <StatusBar
+          projectDir={projectDir}
+          conn={sessionConn}
+          chatTitle={chatTitle}
+          onDaemonStatusChange={setDaemonRunning}
+        />
+      ) : null,
+    [projectDir, sessionConn, chatTitle],
+  );
+
   const allToolCalls = useMemo(
     () => messages.flatMap((m) => m.toolCalls ?? []),
     [messages],
@@ -420,32 +520,65 @@ export function App({
 
   return (
     <Box flexDirection="column" height="100%">
-      <TabBar activeTab={activeTab} />
-      <Divider isLoading={isLoading} />
-
-      {/* Tab content area */}
-      {activeTab === 1 && (
+      {/* Tab content area — all panels stay mounted to avoid expensive
+          remount cycles (especially <Static> in MessageList re-rendering
+          the entire history). display="none" hides inactive panels from
+          layout without destroying them. */}
+      <Box
+        display={activeTab === 1 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
         <MessageList
           messages={messages}
           streamingText={streamingText}
           isLoading={isLoading}
           activeToolCalls={activeToolCalls}
-          isActive={activeTab === 1}
         />
-      )}
-      {activeTab === 2 && (
+      </Box>
+      <Box
+        display={activeTab === 2 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
         <ToolPanel toolCalls={allToolCalls} isActive={activeTab === 2} />
-      )}
-      {activeTab === 3 && (
+      </Box>
+      <Box
+        display={activeTab === 3 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
         <ContextPanel conn={conn} isActive={activeTab === 3} />
-      )}
-      {activeTab === 4 && (
+      </Box>
+      <Box
+        display={activeTab === 4 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
+        <TaskPanel conn={conn} isActive={activeTab === 4} />
+      </Box>
+      <Box
+        display={activeTab === 5 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
+        <ThreadPanel
+          conn={conn}
+          activeThreadId={threadId}
+          isActive={activeTab === 5}
+        />
+      </Box>
+      <Box
+        display={activeTab === 6 ? "flex" : "none"}
+        flexDirection="column"
+        flexGrow={1}
+      >
         <HelpPanel
           projectDir={projectDir}
           threadId={threadId}
           daemonRunning={daemonRunning}
         />
-      )}
+      </Box>
 
       {/* Queued messages (only on Chat tab) */}
       {activeTab === 1 && queuedMessages.length > 0 && (
@@ -455,22 +588,16 @@ export function App({
         />
       )}
 
-      {/* Bottom bar: StatusBar + InputBar (input only on Chat tab) */}
+      {/* Bottom bar: StatusBar + InputBar (input only on Chat tab) + TabBar */}
       <InputBar
         value={inputValue}
         onChange={setInputValue}
         onSubmit={handleSubmit}
         disabled={activeTab !== 1}
         history={inputHistory}
-        header={
-          <StatusBar
-            projectDir={projectDir}
-            conn={conn}
-            isLoading={isLoading}
-            onDaemonStatusChange={setDaemonRunning}
-          />
-        }
+        header={inputBarHeader}
       />
+      <TabBar activeTab={activeTab} />
     </Box>
   );
 }