botholomew 0.15.4 → 0.15.6

package/src/tools/file/copy.ts

@@ -33,7 +33,9 @@ export const contextCopyTool = {
   execute: async (input, ctx) => {
     try {
       if (input.overwrite && (await fileExists(ctx.projectDir, input.dst))) {
-        await deleteContextPath(ctx.projectDir, input.dst);
+        await deleteContextPath(ctx.projectDir, input.dst, {
+          holderId: ctx.workerId,
+        });
       }
       await copyContextPath(ctx.projectDir, input.src, input.dst);
       return { src: input.src, dst: input.dst, is_error: false };

package/src/tools/file/delete.ts

@@ -39,6 +39,7 @@ export const contextDeleteTool = {
     try {
       const result = await deleteContextPath(ctx.projectDir, input.path, {
         recursive: input.recursive,
+        holderId: ctx.workerId,
       });
       return {
         deleted: result.removed,

package/src/tools/file/edit.ts

@@ -2,24 +2,16 @@ import { z } from "zod";
 import {
   applyPatches,
   IsDirectoryError,
+  MtimeConflictError,
   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({
@@ -28,6 +20,7 @@ const outputSchema = z.object({
   is_error: z.boolean(),
   error_type: z.string().optional(),
   message: z.string().optional(),
+  next_action_hint: z.string().optional(),
 });
 
 export const contextEditTool = {
@@ -43,6 +36,7 @@ export const contextEditTool = {
         ctx.projectDir,
         input.path,
         input.patches,
+        { holderId: ctx.workerId },
       );
       const content = await readContextFile(ctx.projectDir, input.path);
       return { applied, content, is_error: false };
@@ -65,6 +59,17 @@ export const contextEditTool = {
           message: `context/${err.path} is a directory`,
         };
       }
+      if (err instanceof MtimeConflictError) {
+        return {
+          applied: 0,
+          content: "",
+          is_error: true,
+          error_type: "mtime_conflict",
+          message: `context/${input.path} was modified concurrently — another writer (or an external editor) changed it between read and write.`,
+          next_action_hint:
+            "Call context_read to fetch the current content, recompute your patches against the new line numbers, and retry.",
+        };
+      }
       throw err;
     }
   },

package/src/tools/file/move.ts

@@ -32,9 +32,14 @@ export const contextMoveTool = {
   execute: async (input, ctx) => {
     try {
       if (input.overwrite && (await fileExists(ctx.projectDir, input.dst))) {
-        await deleteContextPath(ctx.projectDir, input.dst, { recursive: true });
+        await deleteContextPath(ctx.projectDir, input.dst, {
+          recursive: true,
+          holderId: ctx.workerId,
+        });
       }
-      await moveContextPath(ctx.projectDir, input.src, input.dst);
+      await moveContextPath(ctx.projectDir, input.src, input.dst, {
+        holderId: ctx.workerId,
+      });
       return { src: input.src, dst: input.dst, is_error: false };
     } catch (err) {
       if (err instanceof NotFoundError) {

package/src/tools/file/write.ts

@@ -38,7 +38,7 @@ export const contextWriteTool = {
         ctx.projectDir,
         input.path,
         input.content,
-        { onConflict: input.on_conflict ?? "error" },
+        { onConflict: input.on_conflict ?? "error", holderId: ctx.workerId },
       );
       return { path: entry.path, is_error: false };
     } catch (err) {

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