botholomew 0.15.4 → 0.15.5

package/package.json

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

package/src/chat/agent.ts

@@ -52,9 +52,11 @@ const CHAT_TOOL_NAMES = new Set([
   "view_thread",
   "search_threads",
   "create_schedule",
+  "schedule_edit",
   "list_schedules",
-  "update_beliefs",
-  "update_goals",
+  "prompt_read",
+  "prompt_edit",
+  "task_edit",
   "capabilities_refresh",
   "mcp_list_tools",
   "mcp_search",
@@ -100,7 +102,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. Files the agent can read and write live under \`context/\` as project-relative paths (e.g. \`notes/foo.md\`). Use \`context_tree\` to see what's there, \`search\` (hybrid regexp + semantic) to find content, then \`context_read\` / \`context_info\` to drill in.
 Past conversations live in CSV files under \`threads/\`; use \`list_threads\`, \`search_threads\`, and \`view_thread\` to find and page through them.
 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 read and edit the agent's prompt files (beliefs, goals, capabilities, soul) under \`prompts/\` via \`prompt_read\` and \`prompt_edit\` (line-range patches). Files marked \`agent-modification: false\` (e.g. soul.md) are read-only.
 You can author and refine slash-command skills (reusable prompt templates stored in \`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.
 `;
@@ -252,7 +254,7 @@ export async function runChatTurn(input: {
     // Rebuild the system prompt every iteration so that:
     //   (1) `loading: contextual` files get matched against the latest user
     //       message, and
-    //   (2) any update_beliefs / update_goals tool call in the previous
+    //   (2) any prompt_edit tool call in the previous
     //       iteration is reflected in the next LLM call.
     const keywordSource = findLastUserText(messages);
     const systemPrompt = await buildChatSystemPrompt(projectDir, {

package/src/context/store.ts

@@ -13,6 +13,7 @@ import {
 import { dirname, join, posix, relative, sep } from "node:path";
 import { CONTEXT_DIR, PROTECTED_AREAS } from "../constants.ts";
 import { atomicWrite } from "../fs/atomic.ts";
+import { applyLinePatches, type LinePatch } from "../fs/patches.ts";
 import {
   getCanonicalRoot,
   PathEscapeError,
@@ -59,11 +60,7 @@ export class PathConflictError extends Error {
   }
 }
 
-export interface Patch {
-  start_line: number;
-  end_line: number;
-  content: string;
-}
+export type Patch = LinePatch;
 
 export interface ContextEntry {
   /** Project-relative path under context/, e.g. "notes/foo.md". Forward-slashes. */
@@ -775,26 +772,11 @@ export async function applyPatches(
   patches: Patch[],
 ): Promise<{ applied: number; lines: number }> {
   const content = await readContextFile(projectDir, path);
-  const lines = content.split("\n");
-
-  const sorted = [...patches].sort((a, b) => b.start_line - a.start_line);
-
-  for (const patch of sorted) {
-    if (patch.end_line === 0) {
-      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
-      lines.splice(patch.start_line - 1, 0, ...insertLines);
-    } else {
-      const deleteCount = patch.end_line - patch.start_line + 1;
-      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
-      lines.splice(patch.start_line - 1, deleteCount, ...insertLines);
-    }
-  }
-
-  const newContent = lines.join("\n");
+  const newContent = applyLinePatches(content, patches);
   await writeContextFile(projectDir, path, newContent, {
     onConflict: "overwrite",
   });
-  return { applied: patches.length, lines: lines.length };
+  return { applied: patches.length, lines: newContent.split("\n").length };
 }
 
 /**

package/src/fs/patches.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export interface LinePatch {
+  start_line: number;
+  end_line: number;
+  content: string;
+}
+
+export const LinePatchSchema = z.object({
+  start_line: z.number().describe("1-based inclusive start line"),
+  end_line: z
+    .number()
+    .describe("1-based inclusive end line (0 to insert without replacing)"),
+  content: z
+    .string()
+    .describe("Replacement text (empty string to delete lines)"),
+});
+
+/**
+ * Apply git-style line-range patches to a string. Patches are applied
+ * bottom-up so earlier line numbers stay stable. `end_line === 0` is an
+ * insert that doesn't replace; an empty `content` deletes.
+ */
+export function applyLinePatches(raw: string, patches: LinePatch[]): string {
+  const lines = raw.split("\n");
+  const sorted = [...patches].sort((a, b) => b.start_line - a.start_line);
+
+  for (const patch of sorted) {
+    const insertLines = patch.content === "" ? [] : patch.content.split("\n");
+    if (patch.end_line === 0) {
+      lines.splice(patch.start_line - 1, 0, ...insertLines);
+    } else {
+      const deleteCount = patch.end_line - patch.start_line + 1;
+      lines.splice(patch.start_line - 1, deleteCount, ...insertLines);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/schedules/store.ts

@@ -19,7 +19,7 @@ import {
   ScheduleFrontmatterSchema,
 } from "./schema.ts";
 
-function scheduleFilePath(projectDir: string, id: string): string {
+export function scheduleFilePath(projectDir: string, id: string): string {
   return join(getSchedulesDir(projectDir), `${id}.md`);
 }
 
@@ -27,20 +27,26 @@ function scheduleLockPath(projectDir: string, id: string): string {
   return join(getSchedulesLockDir(projectDir), `${id}.lock`);
 }
 
-function serializeSchedule(fm: ScheduleFrontmatter, body: string): string {
+export function serializeSchedule(
+  fm: ScheduleFrontmatter,
+  body: string,
+): string {
   return matter.stringify(`\n${body.trim()}\n`, fm as Record<string, unknown>);
 }
 
-interface ParseOk {
+export interface ScheduleParseOk {
   ok: true;
   schedule: Schedule;
 }
-interface ParseFail {
+export interface ScheduleParseFail {
   ok: false;
   reason: string;
 }
 
-function parseScheduleFile(raw: string, mtimeMs: number): ParseOk | ParseFail {
+export function parseScheduleFile(
+  raw: string,
+  mtimeMs: number,
+): ScheduleParseOk | ScheduleParseFail {
   let parsed: matter.GrayMatterFile<string>;
   try {
     parsed = matter(raw);

package/src/tasks/store.ts

@@ -21,7 +21,7 @@ import {
   type TaskStatus,
 } from "./schema.ts";
 
-function taskFilePath(projectDir: string, id: string): string {
+export function taskFilePath(projectDir: string, id: string): string {
   return join(getTasksDir(projectDir), `${id}.md`);
 }
 
@@ -33,23 +33,23 @@ function taskLockPath(projectDir: string, id: string): string {
  * Render a Task to its on-disk markdown form. Frontmatter contains every
  * field; the body is preserved as-is. Trailing newline keeps line count sane.
  */
-function serializeTask(fm: TaskFrontmatter, body: string): string {
+export function serializeTask(fm: TaskFrontmatter, body: string): string {
   return matter.stringify(`\n${body.trim()}\n`, fm as Record<string, unknown>);
 }
 
-interface ParseResult {
+export interface TaskParseOk {
   ok: true;
   task: Task;
 }
-interface ParseFailure {
+export interface TaskParseFail {
   ok: false;
   reason: string;
 }
 
-function parseTaskFile(
+export function parseTaskFile(
   raw: string,
   mtimeMs: number,
-): ParseResult | ParseFailure {
+): TaskParseOk | TaskParseFail {
   let parsed: matter.GrayMatterFile<string>;
   try {
     parsed = matter(raw);

package/src/tools/file/edit.ts

@@ -5,21 +5,12 @@ import {
   NotFoundError,
   readContextFile,
 } from "../../context/store.ts";
+import { LinePatchSchema } from "../../fs/patches.ts";
 import type { ToolDefinition } from "../tool.ts";
 
-const PatchSchema = z.object({
-  start_line: z.number().describe("1-based inclusive start line"),
-  end_line: z
-    .number()
-    .describe("1-based inclusive end line (0 to insert without replacing)"),
-  content: z
-    .string()
-    .describe("Replacement text (empty string to delete lines)"),
-});
-
 const inputSchema = z.object({
   path: z.string().describe("Project-relative path under context/"),
-  patches: z.array(PatchSchema).describe("Patches to apply"),
+  patches: z.array(LinePatchSchema).describe("Patches to apply"),
 });
 
 const outputSchema = z.object({

package/src/tools/prompt/edit.ts

@@ -0,0 +1,148 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { getPromptsDir } from "../../constants.ts";
+import {
+  atomicWriteIfUnchanged,
+  MtimeConflictError,
+  readWithMtime,
+} from "../../fs/atomic.ts";
+import { applyLinePatches, LinePatchSchema } from "../../fs/patches.ts";
+import {
+  parseContextFile,
+  serializeContextFile,
+} from "../../utils/frontmatter.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  name: z
+    .string()
+    .describe(
+      "Prompt name without extension (e.g. 'beliefs', 'goals', 'capabilities'). Resolves to prompts/<name>.md.",
+    ),
+  patches: z.array(LinePatchSchema).describe("Patches to apply"),
+});
+
+const outputSchema = z.object({
+  name: 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 promptEditTool = {
+  name: "prompt_edit",
+  description:
+    "[[ bash equivalent command: patch ]] Apply git-style line-range patches to a prompt file under prompts/. Operates on the whole file (frontmatter + body). Files marked `agent-modification: false` (e.g. soul.md) are protected. Use prompt_read first to inspect current line numbers.",
+  group: "context",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    if (input.name.includes("/") || input.name.includes("..")) {
+      return {
+        name: input.name,
+        path: null,
+        applied: 0,
+        content: "",
+        is_error: true,
+        error_type: "invalid_name",
+        message: `Invalid prompt name: ${input.name}`,
+        next_action_hint:
+          "Use a basename without slashes or dots (e.g. 'beliefs').",
+      };
+    }
+    const filePath = join(getPromptsDir(ctx.projectDir), `${input.name}.md`);
+    const file = await readWithMtime(filePath);
+    if (!file) {
+      return {
+        name: input.name,
+        path: null,
+        applied: 0,
+        content: "",
+        is_error: true,
+        error_type: "not_found",
+        message: `Prompt not found: prompts/${input.name}.md`,
+      };
+    }
+
+    const original = file.content;
+    const preParsed = parseContextFile(original);
+    if (!preParsed.meta["agent-modification"]) {
+      return {
+        name: input.name,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "agent_modification_disabled",
+        message: `Agent modification not allowed for prompts/${input.name}.md`,
+      };
+    }
+
+    const updated = applyLinePatches(original, input.patches);
+    let postParsed: { meta: Record<string, unknown>; content: string };
+    try {
+      postParsed = parseContextFile(updated);
+    } catch (err) {
+      return {
+        name: input.name,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "invalid_frontmatter",
+        message: `Patched content failed to parse: ${err instanceof Error ? err.message : String(err)}`,
+        next_action_hint:
+          "Check that the frontmatter delimiters and YAML stay valid.",
+      };
+    }
+    if (!postParsed.meta["agent-modification"]) {
+      return {
+        name: input.name,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "agent_modification_disabled",
+        message: `Patch would clear agent-modification on prompts/${input.name}.md`,
+        next_action_hint:
+          "Don't change the agent-modification frontmatter flag.",
+      };
+    }
+
+    const serialized = serializeContextFile(
+      postParsed.meta,
+      postParsed.content,
+    );
+
+    try {
+      await atomicWriteIfUnchanged(filePath, serialized, file.mtimeMs);
+    } catch (err) {
+      if (err instanceof MtimeConflictError) {
+        return {
+          name: input.name,
+          path: filePath,
+          applied: 0,
+          content: original,
+          is_error: true,
+          error_type: "mtime_conflict",
+          message: `Prompt was modified concurrently: ${err.message}`,
+          next_action_hint:
+            "Re-read with prompt_read and recompute your patch line numbers before retrying.",
+        };
+      }
+      throw err;
+    }
+
+    return {
+      name: input.name,
+      path: filePath,
+      applied: input.patches.length,
+      content: serialized,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/prompt/read.ts

@@ -0,0 +1,70 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { getPromptsDir } from "../../constants.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  name: z
+    .string()
+    .describe(
+      "Prompt name without extension (e.g. 'beliefs', 'goals', 'capabilities'). Resolves to prompts/<name>.md.",
+    ),
+});
+
+const outputSchema = z.object({
+  name: z.string(),
+  path: z.string().nullable(),
+  content: z.string(),
+  agent_modification: z.boolean(),
+  is_error: z.boolean(),
+  error_type: z.string().optional(),
+  message: z.string().optional(),
+});
+
+export const promptReadTool = {
+  name: "prompt_read",
+  description:
+    "[[ bash equivalent command: cat ]] Read a prompt file under prompts/ (e.g. beliefs, goals, capabilities, soul). Returns the whole file (frontmatter + body) for use with prompt_edit.",
+  group: "context",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    if (input.name.includes("/") || input.name.includes("..")) {
+      return {
+        name: input.name,
+        path: null,
+        content: "",
+        agent_modification: false,
+        is_error: true,
+        error_type: "invalid_name",
+        message: `Invalid prompt name: ${input.name}`,
+      };
+    }
+    const filePath = join(getPromptsDir(ctx.projectDir), `${input.name}.md`);
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
+      return {
+        name: input.name,
+        path: null,
+        content: "",
+        agent_modification: false,
+        is_error: true,
+        error_type: "not_found",
+        message: `Prompt not found: prompts/${input.name}.md`,
+      };
+    }
+    const content = await file.text();
+    // Cheap header sniff so the agent knows whether prompt_edit will be
+    // accepted before it constructs patches.
+    const agent_modification = /agent-modification:\s*true/.test(
+      content.split("---", 3).slice(0, 3).join("---"),
+    );
+    return {
+      name: input.name,
+      path: filePath,
+      content,
+      agent_modification,
+      is_error: false,
+    };
+  },
+} satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;

package/src/tools/registry.ts

@@ -3,8 +3,6 @@ import { capabilitiesRefreshTool } from "./capabilities/refresh.ts";
 // Context tools
 import { pipeToContextTool } from "./context/pipe.ts";
 import { readLargeResultTool } from "./context/read-large-result.ts";
-import { updateBeliefsTool } from "./context/update-beliefs.ts";
-import { updateGoalsTool } from "./context/update-goals.ts";
 // Context — directory operations
 import { contextCreateDirTool } from "./dir/create.ts";
 import { contextDirSizeTool } from "./dir/size.ts";
@@ -24,8 +22,12 @@ import { mcpExecTool } from "./mcp/exec.ts";
 import { mcpInfoTool } from "./mcp/info.ts";
 import { mcpListToolsTool } from "./mcp/list-tools.ts";
 import { mcpSearchTool } from "./mcp/search.ts";
+// Prompt tools
+import { promptEditTool } from "./prompt/edit.ts";
+import { promptReadTool } from "./prompt/read.ts";
 // Schedule tools
 import { createScheduleTool } from "./schedule/create.ts";
+import { scheduleEditTool } from "./schedule/edit.ts";
 import { listSchedulesTool } from "./schedule/list.ts";
 // Search tools
 import { searchTool } from "./search/index.ts";
@@ -40,6 +42,7 @@ import { skillWriteTool } from "./skill/write.ts";
 import { completeTaskTool } from "./task/complete.ts";
 import { createTaskTool } from "./task/create.ts";
 import { deleteTaskTool } from "./task/delete.ts";
+import { taskEditTool } from "./task/edit.ts";
 import { failTaskTool } from "./task/fail.ts";
 import { listTasksTool } from "./task/list.ts";
 import { updateTaskTool } from "./task/update.ts";
@@ -62,6 +65,7 @@ export function registerAllTools(): void {
   registerTool(waitTaskTool);
   registerTool(createTaskTool);
   registerTool(updateTaskTool);
+  registerTool(taskEditTool);
   registerTool(deleteTaskTool);
   registerTool(listTasksTool);
   registerTool(viewTaskTool);
@@ -79,8 +83,8 @@ export function registerAllTools(): void {
   registerTool(contextInfoTool);
   registerTool(contextExistsTool);
   registerTool(contextCountLinesTool);
-  registerTool(updateBeliefsTool);
-  registerTool(updateGoalsTool);
+  registerTool(promptReadTool);
+  registerTool(promptEditTool);
   registerTool(readLargeResultTool);
   registerTool(pipeToContextTool);
 
@@ -89,6 +93,7 @@ export function registerAllTools(): void {
 
   // Schedule
   registerTool(createScheduleTool);
+  registerTool(scheduleEditTool);
   registerTool(listSchedulesTool);
 
   // Search

package/src/tools/schedule/edit.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import {
+  atomicWriteIfUnchanged,
+  MtimeConflictError,
+  readWithMtime,
+} from "../../fs/atomic.ts";
+import { applyLinePatches, LinePatchSchema } from "../../fs/patches.ts";
+import type { ScheduleFrontmatter } from "../../schedules/schema.ts";
+import {
+  parseScheduleFile,
+  scheduleFilePath,
+  serializeSchedule,
+} from "../../schedules/store.ts";
+import type { ToolDefinition } from "../tool.ts";
+
+const inputSchema = z.object({
+  id: z.string().describe("Schedule 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 scheduleEditTool = {
+  name: "schedule_edit",
+  description:
+    "[[ bash equivalent command: patch ]] Apply git-style line-range patches to a schedule file. Operates on the whole file (frontmatter + body). Patches whose result fails frontmatter validation are rejected without writing. Re-serializes to canonicalize YAML and bump updated_at. Use schedule_list to find ids.",
+  group: "schedule",
+  inputSchema,
+  outputSchema,
+  execute: async (input, ctx) => {
+    const filePath = scheduleFilePath(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: `Schedule not found: ${input.id}`,
+        next_action_hint:
+          "Use schedule_list to see available schedules, or create_schedule to make one.",
+      };
+    }
+
+    const original = file.content;
+    const updated = applyLinePatches(original, input.patches);
+
+    const parsed = parseScheduleFile(updated, file.mtimeMs);
+    if (!parsed.ok) {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "invalid_schedule",
+        message: `Patched content failed validation: ${parsed.reason}`,
+        next_action_hint:
+          "Check that frontmatter YAML stays valid and required fields (id, name, frequency, enabled, created_at, updated_at) are preserved.",
+      };
+    }
+    if (parsed.schedule.id !== input.id) {
+      return {
+        id: input.id,
+        path: filePath,
+        applied: 0,
+        content: original,
+        is_error: true,
+        error_type: "id_mismatch",
+        message: `frontmatter id '${parsed.schedule.id}' does not match the schedule id '${input.id}'`,
+        next_action_hint:
+          "Don't change the id frontmatter field; create a new schedule with create_schedule if you need a different id.",
+      };
+    }
+
+    const fm: ScheduleFrontmatter = {
+      id: parsed.schedule.id,
+      name: parsed.schedule.name,
+      description: parsed.schedule.description,
+      frequency: parsed.schedule.frequency,
+      enabled: parsed.schedule.enabled,
+      last_run_at: parsed.schedule.last_run_at,
+      created_at: parsed.schedule.created_at,
+      updated_at: new Date().toISOString(),
+    };
+    const serialized = serializeSchedule(fm, parsed.schedule.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: `Schedule was modified concurrently: ${err.message}`,
+          next_action_hint:
+            "Re-read the schedule with schedule_list 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/skill/edit.ts

@@ -1,22 +1,13 @@
 import { join } from "node:path";
 import { z } from "zod";
 import { getSkillsDir } from "../../constants.ts";
+import { applyLinePatches, LinePatchSchema } from "../../fs/patches.ts";
 import { parseSkillFile } from "../../skills/parser.ts";
 import type { ToolDefinition } from "../tool.ts";
 
-const PatchSchema = z.object({
-  start_line: z.number().describe("1-based inclusive start line"),
-  end_line: z
-    .number()
-    .describe("1-based inclusive end line (0 to insert without replacing)"),
-  content: z
-    .string()
-    .describe("Replacement text (empty string to delete lines)"),
-});
-
 const inputSchema = z.object({
   name: z.string().describe("Skill name (case-insensitive)"),
-  patches: z.array(PatchSchema).describe("Patches to apply"),
+  patches: z.array(LinePatchSchema).describe("Patches to apply"),
 });
 
 const outputSchema = z.object({
@@ -30,27 +21,6 @@ const outputSchema = z.object({
   next_action_hint: z.string().optional(),
 });
 
-function applyPatches(
-  raw: string,
-  patches: Array<{ start_line: number; end_line: number; content: string }>,
-): string {
-  const lines = raw.split("\n");
-  const sorted = [...patches].sort((a, b) => b.start_line - a.start_line);
-
-  for (const patch of sorted) {
-    if (patch.end_line === 0) {
-      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
-      lines.splice(patch.start_line - 1, 0, ...insertLines);
-    } else {
-      const deleteCount = patch.end_line - patch.start_line + 1;
-      const insertLines = patch.content === "" ? [] : patch.content.split("\n");
-      lines.splice(patch.start_line - 1, deleteCount, ...insertLines);
-    }
-  }
-
-  return lines.join("\n");
-}
-
 export const skillEditTool = {
   name: "skill_edit",
   description:
@@ -78,7 +48,7 @@ export const skillEditTool = {
     }
 
     const original = await file.text();
-    const updated = applyPatches(original, input.patches);
+    const updated = applyLinePatches(original, input.patches);
 
     try {
       const parsed = parseSkillFile(updated, filePath);

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/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[]>([]);
@@ -586,6 +610,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("");
 
@@ -656,6 +682,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 +728,9 @@ function AppInner({
                     timestamp: new Date(),
                   },
                 ]);
+              } finally {
+                clearingRef.current = false;
+                setClearing(false);
               }
             })();
           },
@@ -774,7 +809,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 +821,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 +914,7 @@ function AppInner({
         value={inputValue}
         onChange={setInputValue}
         onSubmit={handleSubmit}
-        disabled={activeTab !== 1}
+        disabled={activeTab !== 1 || clearing}
         history={inputHistory}
         header={inputBarHeader}
         slashCommands={slashCommands}

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>;