botholomew 0.15.4 → 0.15.6

package/src/tools/task/edit.ts

@@ -0,0 +1,214 @@
+import { z } from "zod";
+import {
+  atomicWriteIfUnchanged,
+  MtimeConflictError,
+  readWithMtime,
+} from "../../fs/atomic.ts";
+import { applyLinePatches, LinePatchSchema } from "../../fs/patches.ts";
+import type { TaskFrontmatter } from "../../tasks/schema.ts";
+import {
+  CircularDependencyError,
+  parseTaskFile,
+  serializeTask,
+  taskFilePath,
+  validateBlockedBy,
+} from "../../tasks/store.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  id: z.string().describe("Task id"),
+  patches: z.array(LinePatchSchema).describe("Patches to apply"),
+});
+
+const outputSchema = z.object({
+  id: z.string(),
+  path: z.string().nullable(),
+  applied: z.number(),
+  content: z.string(),
+  is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+  next_action_hint: z.string().optional(),
+});
+
+export const taskEditTool = {
+  name: "task_edit",
+  description:
+    "[[ bash equivalent command: patch ]] Apply git-style line-range patches to a task file. Operates on the whole file (frontmatter + body). Only pending tasks may be edited. Patches that fail validation or introduce a circular dependency are rejected without writing. Re-serializes to canonicalize YAML and bump updated_at.",
+  group: "task",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const filePath = taskFilePath(ctx.projectDir, input.id);
+    const file = await readWithMtime(filePath);
+    if (!file) {
+      return {
+        id: input.id,
+        path: null,
+        applied: 0,
+        content: "",
+        is_error: true,
+        error_type: "not_found",
+        message: `Task not found: ${input.id}`,
+        next_action_hint:
+          "Use list_tasks to see available tasks, or create_task to make one.",
+      };
+    }
+
+    const original = file.content;
+    const preParsed = parseTaskFile(original, file.mtimeMs);
+    if (!preParsed.ok) {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "invalid_task",
+        message: `Existing task file is malformed: ${preParsed.reason}`,
+      };
+    }
+    if (preParsed.task.status !== "pending") {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "not_pending",
+        message: `Cannot edit task ${input.id}: only pending tasks can be edited (current status: ${preParsed.task.status})`,
+        next_action_hint:
+          "Use complete_task / fail_task / wait_task for terminal status changes.",
+      };
+    }
+
+    const updated = applyLinePatches(original, input.patches);
+    const parsed = parseTaskFile(updated, file.mtimeMs);
+    if (!parsed.ok) {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "invalid_task",
+        message: `Patched content failed validation: ${parsed.reason}`,
+        next_action_hint:
+          "Check that frontmatter YAML stays valid and required fields (id, name, status, priority, etc.) are preserved.",
+      };
+    }
+    if (parsed.task.id !== input.id) {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "id_mismatch",
+        message: `frontmatter id '${parsed.task.id}' does not match the task id '${input.id}'`,
+        next_action_hint:
+          "Don't change the id frontmatter field; create a new task with create_task if you need a different id.",
+      };
+    }
+    if (parsed.task.status !== "pending") {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "status_change_forbidden",
+        message: `Patch would change task status from 'pending' to '${parsed.task.status}'. Status transitions must go through complete_task / fail_task / wait_task so the terminal-tool loop and summary are recorded.`,
+        next_action_hint:
+          "Don't edit the status frontmatter field; use complete_task, fail_task, or wait_task to transition state.",
+      };
+    }
+    // Worker-managed fields: claim state is set by claimNextTask /
+    // releaseTaskLock, output by complete_task, waiting_reason by wait_task.
+    // A pending task should have all four null; refuse any patch that
+    // changes them so the agent can't backdoor a claim or fake an output.
+    const workerManaged: Array<keyof typeof parsed.task> = [
+      "claimed_by",
+      "claimed_at",
+      "output",
+      "waiting_reason",
+    ];
+    for (const field of workerManaged) {
+      if (parsed.task[field] !== preParsed.task[field]) {
+        return {
+          id: input.id,
+          path: filePath,
+          applied: 0,
+          content: original,
+          is_error: true,
+          error_type: "worker_field_change_forbidden",
+          message: `Patch would change worker-managed field '${field}'. Only complete_task / fail_task / wait_task / the claim loop may set claimed_by, claimed_at, output, and waiting_reason.`,
+          next_action_hint: `Don't edit the ${field} frontmatter field.`,
+        };
+      }
+    }
+
+    try {
+      await validateBlockedBy(ctx.projectDir, input.id, parsed.task.blocked_by);
+    } catch (err) {
+      if (err instanceof CircularDependencyError) {
+        return {
+          id: input.id,
+          path: filePath,
+          applied: 0,
+          content: original,
+          is_error: true,
+          error_type: "circular_dependency",
+          message: err.message,
+          next_action_hint:
+            "Pick blockers that don't transitively depend on this task.",
+        };
+      }
+      throw err;
+    }
+
+    const fm: TaskFrontmatter = {
+      id: parsed.task.id,
+      name: parsed.task.name,
+      description: parsed.task.description,
+      priority: parsed.task.priority,
+      status: parsed.task.status,
+      blocked_by: parsed.task.blocked_by,
+      context_paths: parsed.task.context_paths,
+      output: parsed.task.output,
+      waiting_reason: parsed.task.waiting_reason,
+      claimed_by: parsed.task.claimed_by,
+      claimed_at: parsed.task.claimed_at,
+      created_at: parsed.task.created_at,
+      updated_at: new Date().toISOString(),
+    };
+    const serialized = serializeTask(fm, parsed.task.body);
+
+    try {
+      await atomicWriteIfUnchanged(filePath, serialized, file.mtimeMs);
+    } catch (err) {
+      if (err instanceof MtimeConflictError) {
+        return {
+          id: input.id,
+          path: filePath,
+          applied: 0,
+          content: original,
+          is_error: true,
+          error_type: "mtime_conflict",
+          message: `Task was modified concurrently: ${err.message}`,
+          next_action_hint:
+            "Re-read the task with view_task and recompute your patch line numbers before retrying.",
+        };
+      }
+      throw err;
+    }
+
+    return {
+      id: input.id,
+      path: filePath,
+      applied: input.patches.length,
+      content: serialized,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/tool.ts

@@ -17,6 +17,15 @@ export interface ToolContext {
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;
+  /**
+   * Identifier of the agent process running this tool, used as the holder
+   * id for per-path context locks (`src/context/locks.ts`) so the worker
+   * reaper can identify and release locks abandoned by a crashed worker.
+   * Workers pass their `workerId`; chat sessions pass a `chat:` prefixed
+   * id; tests and one-off CLI calls leave it `undefined` (the store falls
+   * back to `pid:<n>`).
+   */
+  workerId?: string;
   /**
    * Chat-mode only. Lets long-running tools (e.g. `sleep`) poll for
    * Esc-to-abort by reading `session.aborted`. Workers leave this `undefined`.

package/src/tui/App.tsx

@@ -1,4 +1,4 @@
-import { Box, Static, Text, useApp, useInput } from "ink";
+import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   abortActiveStream,
@@ -174,9 +174,33 @@ function AppInner({
   initialPrompt,
 }: AppInnerProps) {
   const { exit } = useApp();
+  const { stdout } = useStdout();
   const { markActivity } = useIdle();
+  // Pin the root box to a known viewport height so the rendered frame size
+  // never crosses the viewport boundary. Ink 7's renderer wipes scrollback
+  // (`shouldClearTerminalForFrame` → `ansiEscapes.clearTerminal`) whenever
+  // the dynamic frame transitions in/out of fullscreen, so a fluctuating
+  // `outputHeight` (streaming text + tool boxes appearing/disappearing) used
+  // to delete the chat history on every turn. Ink doesn't pin a height on
+  // its internal root, so a `height="100%"` on our root collapses to `auto`
+  // — we have to pass the explicit row count and re-read it on resize.
+  const [rows, setRows] = useState(stdout?.rows ?? 24);
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => setRows(stdout.rows ?? 24);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
   const [messages, setMessages] = useState<ChatMessage[]>([]);
   const [messagesEpoch, setMessagesEpoch] = useState(0);
+  // `clearing` gates new submissions while /clear's async work is in flight.
+  // Without it, a message submitted during the clearChatSession await runs
+  // sendMessage against the OLD thread id, then the IIFE's setMessages([sys])
+  // overwrites the user bubble it added — the message disappears.
+  const [clearing, setClearing] = useState(false);
+  const clearingRef = useRef(false);
   const [usage, setUsage] = useState<ContextUsage | null>(null);
   const [inputValue, setInputValue] = useState("");
   const [inputHistory, setInputHistory] = useState<string[]>([]);
@@ -192,6 +216,7 @@ function AppInner({
   const [splashDone, setSplashDone] = useState(skipSplash);
   const [error, setError] = useState<string | null>(null);
   const sessionRef = useRef<ChatSession | null>(null);
+  const shuttingDownRef = useRef(false);
   const [activeTab, setActiveTab] = useState<TabId>(1);
   const [workerRunning, setWorkerRunning] = useState(false);
   const [chatTitle, setChatTitle] = useState<string | undefined>(undefined);
@@ -251,16 +276,52 @@ function AppInner({
 
     return () => {
       cancelled = true;
+      // Fire-and-forget safety net: only triggers when unmount happens via a
+      // path that didn't go through performShutdown (which nulls sessionRef
+      // first). React doesn't await unmount cleanups, so the goodbye lands
+      // before mcpx finishes closing — that's fine for non-Ctrl-C paths.
       if (sessionRef.current) {
-        const threadId = sessionRef.current.threadId;
-        endChatSession(sessionRef.current);
+        const session = sessionRef.current;
+        const threadId = session.threadId;
+        abortActiveStream(session);
+        void endChatSession(session);
         process.stderr.write(
-          `\nThread: ${threadId}\nResume with: ${ansi.success}botholomew chat --thread-id ${threadId}${ansi.reset}\n`,
+          `\nThread: ${threadId}\nResume with: ${ansi.success}botholomew chat --thread-id ${threadId}${ansi.reset}\nBye!\n`,
         );
       }
     };
   }, [projectDir, resumeThreadId]);
 
+  const performShutdown = useCallback(async () => {
+    if (shuttingDownRef.current) {
+      // Second Ctrl-C while cleanup is in flight — give the user an escape
+      // hatch. 130 = standard SIGINT exit code.
+      process.exit(130);
+    }
+    shuttingDownRef.current = true;
+
+    const session = sessionRef.current;
+    // Null the ref so the useEffect cleanup that runs on Ink unmount becomes
+    // a no-op — otherwise it would double-print the goodbye and double-close
+    // the mcpx client.
+    sessionRef.current = null;
+
+    if (session) {
+      const threadId = session.threadId;
+      abortActiveStream(session);
+      try {
+        await endChatSession(session);
+      } catch {
+        // Best-effort: the user pressed Ctrl-C, surfacing a stack trace here
+        // would just hide the goodbye line.
+      }
+      process.stderr.write(
+        `\nThread: ${threadId}\nResume with: ${ansi.success}botholomew chat --thread-id ${threadId}${ansi.reset}\nBye!\n`,
+      );
+    }
+    exit();
+  }, [exit]);
+
   // Minimum splash screen duration
   useEffect(() => {
     const timer = setTimeout(() => setSplashDone(true), 2000);
@@ -309,9 +370,12 @@ function AppInner({
     (input: string, key: any) => {
       markActivityRef.current();
 
-      // Ctrl+C exits
+      // Ctrl+C exits. Routed through performShutdown so the in-flight LLM
+      // stream is aborted and mcpx is closed before we unmount Ink — without
+      // that, one Ctrl-C prints the goodbye but the process stays pinned by
+      // the open HTTPS socket and a second Ctrl-C is needed.
       if (input === "c" && key.ctrl) {
-        exit();
+        void performShutdown();
         return;
       }
 
@@ -393,7 +457,7 @@ function AppInner({
         }
       }
     },
-    [exit, syncQueue],
+    [performShutdown, syncQueue],
   );
 
   useInput(stableAppHandler);
@@ -586,6 +650,8 @@ function AppInner({
     async (text: string) => {
       const trimmed = text.trim();
       if (!trimmed || !sessionRef.current) return;
+      // /clear is mid-flight: don't queue against the old thread id.
+      if (clearingRef.current) return;
 
       setInputValue("");
 
@@ -643,7 +709,7 @@ function AppInner({
             syncQueue();
             processQueue();
           },
-          exit,
+          exit: () => void performShutdown(),
           clearChat: () => {
             const session = sessionRef.current;
             if (!session) return;
@@ -656,6 +722,12 @@ function AppInner({
             // poll below immediately rather than waiting on the
             // createThread/endThread round trip first.
             abortActiveStream(session);
+            // Block new submissions until the new thread id is in place —
+            // otherwise the user's first post-/clear message races the
+            // async createThread, runs against the old thread id, and is
+            // then wiped by setMessages([sys]) below.
+            clearingRef.current = true;
+            setClearing(true);
             void (async () => {
               // Wait for any in-flight processQueue iteration to finish so
               // its trailing `finalizeSegment` can't race our state reset
@@ -696,6 +768,9 @@ function AppInner({
                     timestamp: new Date(),
                   },
                 ]);
+              } finally {
+                clearingRef.current = false;
+                setClearing(false);
               }
             })();
           },
@@ -708,7 +783,7 @@ function AppInner({
       syncQueue();
       processQueue();
     },
-    [exit, processQueue, syncQueue],
+    [performShutdown, processQueue, syncQueue],
   );
 
   const sessionDbPath = sessionRef.current?.dbPath;
@@ -774,7 +849,7 @@ function AppInner({
   const threadId = sessionRef.current.threadId;
 
   return (
-    <Box flexDirection="column" height="100%">
+    <Box flexDirection="column" height={rows} overflow="hidden">
       {/* Completed messages — rendered once to terminal scrollback.
           Must live outside the display="none" tab wrappers so the <Static>
           node always has proper terminal width in its Yoga layout.
@@ -786,11 +861,19 @@ function AppInner({
 
       {/* Tab content area — all panels stay mounted to avoid expensive
           remount cycles. display="none" hides inactive panels from
-          layout without destroying them. */}
+          layout without destroying them.
+          The chat tab's flexGrow box is overflow-clipped so streaming
+          content can't push the rendered frame past the viewport — see
+          the comment on the `rows` state for why that matters.
+          `justifyContent="flex-end"` keeps active streaming content + the
+          tool-call card pinned to the bottom of the chat area (just
+          above the input bar) instead of leaving a tall gap below them. */}
       <Box
         display={activeTab === 1 ? "flex" : "none"}
         flexDirection="column"
         flexGrow={1}
+        overflow="hidden"
+        justifyContent="flex-end"
       >
         <MessageList
           streamingText={streamingText}
@@ -871,7 +954,7 @@ function AppInner({
         value={inputValue}
         onChange={setInputValue}
         onSubmit={handleSubmit}
-        disabled={activeTab !== 1}
+        disabled={activeTab !== 1 || clearing}
         history={inputHistory}
         header={inputBarHeader}
         slashCommands={slashCommands}

package/src/worker/heartbeat.ts

@@ -1,3 +1,4 @@
+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";
@@ -81,6 +82,25 @@ 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,

package/src/worker/llm.ts

@@ -53,6 +53,7 @@ export async function runAgentLoop(input: {
   dbPath: string;
   threadId: string;
   projectDir: string;
+  workerId?: string;
   mcpxClient?: McpxClient | null;
   callbacks?: WorkerStreamCallbacks;
 }): Promise<AgentLoopResult> {
@@ -63,6 +64,7 @@ export async function runAgentLoop(input: {
     dbPath,
     threadId,
     projectDir,
+    workerId,
     callbacks,
   } = input;
 
@@ -207,6 +209,7 @@ export async function runAgentLoop(input: {
           projectDir,
           config,
           mcpxClient: input.mcpxClient ?? null,
+          workerId,
         });
         const elapsed = Date.now() - start;
         callbacks?.onToolEnd(
@@ -265,6 +268,7 @@ interface ToolCallCtx {
   projectDir: string;
   config: Required<BotholomewConfig>;
   mcpxClient: McpxClient | null;
+  workerId?: string;
 }
 
 async function executeToolCall(

package/src/worker/tick.ts

@@ -77,6 +77,7 @@ export async function tick(opts: TickOptions): Promise<boolean> {
     projectDir,
     dbPath,
     config,
+    workerId,
     mcpxClient,
     callbacks,
     task,
@@ -115,6 +116,7 @@ export async function runSpecificTask(opts: {
     projectDir: opts.projectDir,
     dbPath: opts.dbPath,
     config: opts.config,
+    workerId: opts.workerId,
     mcpxClient: opts.mcpxClient,
     callbacks: opts.callbacks,
     task,
@@ -126,11 +128,13 @@ async function runClaimedTask(opts: {
   projectDir: string;
   dbPath: string;
   config: Required<BotholomewConfig>;
+  workerId: string;
   mcpxClient?: McpxClient | null;
   callbacks?: WorkerStreamCallbacks;
   task: Task;
 }): Promise<void> {
-  const { projectDir, dbPath, config, mcpxClient, callbacks, task } = opts;
+  const { projectDir, dbPath, config, workerId, mcpxClient, callbacks, task } =
+    opts;
 
   logger.info(`Claimed task: ${task.name} (${task.id})`);
   if (!callbacks && task.description) {
@@ -161,6 +165,7 @@ async function runClaimedTask(opts: {
       dbPath,
       threadId,
       projectDir,
+      workerId,
       mcpxClient,
       callbacks,
     });

package/src/tools/context/update-beliefs.ts

@@ -1,64 +0,0 @@
-import { join } from "node:path";
-import { z } from "zod";
-import { getPromptsDir } from "../../constants.ts";
-import {
-  type ContextFileMeta,
-  parseContextFile,
-  serializeContextFile,
-} from "../../utils/frontmatter.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  content: z
-    .string()
-    .describe(
-      "The new beliefs content (replaces existing body, frontmatter is preserved)",
-    ),
-});
-
-const outputSchema = z.object({
-  message: z.string(),
-  path: z.string(),
-  is_error: z.boolean(),
-});
-
-export const updateBeliefsTool = {
-  name: "update_beliefs",
-  description:
-    "Update the agent's beliefs file (prompts/beliefs.md). Preserves frontmatter, replaces content body.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    const filePath = join(getPromptsDir(ctx.projectDir), "beliefs.md");
-    const file = Bun.file(filePath);
-
-    let meta: ContextFileMeta = {
-      loading: "always",
-      "agent-modification": true,
-    };
-
-    if (await file.exists()) {
-      const raw = await file.text();
-      const parsed = parseContextFile(raw);
-      meta = parsed.meta;
-
-      if (!meta["agent-modification"]) {
-        return {
-          message: "Agent modification not allowed for this file",
-          path: filePath,
-          is_error: true,
-        };
-      }
-    }
-
-    const serialized = serializeContextFile(meta, input.content);
-    await Bun.write(filePath, serialized);
-
-    return {
-      message: "Updated beliefs.md",
-      path: filePath,
-      is_error: false,
-    };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/context/update-goals.ts

@@ -1,64 +0,0 @@
-import { join } from "node:path";
-import { z } from "zod";
-import { getPromptsDir } from "../../constants.ts";
-import {
-  type ContextFileMeta,
-  parseContextFile,
-  serializeContextFile,
-} from "../../utils/frontmatter.ts";
-import type { ToolDefinition } from "../tool.ts";
-
-const inputSchema = z.object({
-  content: z
-    .string()
-    .describe(
-      "The new goals content (replaces existing body, frontmatter is preserved)",
-    ),
-});
-
-const outputSchema = z.object({
-  message: z.string(),
-  path: z.string(),
-  is_error: z.boolean(),
-});
-
-export const updateGoalsTool = {
-  name: "update_goals",
-  description:
-    "Update the agent's goals file (prompts/goals.md). Preserves frontmatter, replaces content body.",
-  group: "context",
-  inputSchema,
-  outputSchema,
-  execute: async (input, ctx) => {
-    const filePath = join(getPromptsDir(ctx.projectDir), "goals.md");
-    const file = Bun.file(filePath);
-
-    let meta: ContextFileMeta = {
-      loading: "always",
-      "agent-modification": true,
-    };
-
-    if (await file.exists()) {
-      const raw = await file.text();
-      const parsed = parseContextFile(raw);
-      meta = parsed.meta;
-
-      if (!meta["agent-modification"]) {
-        return {
-          message: "Agent modification not allowed for this file",
-          path: filePath,
-          is_error: true,
-        };
-      }
-    }
-
-    const serialized = serializeContextFile(meta, input.content);
-    await Bun.write(filePath, serialized);
-
-    return {
-      message: "Updated goals.md",
-      path: filePath,
-      is_error: false,
-    };
-  },
-} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;