botholomew 0.15.5 → 0.16.0

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/prompt.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import type { BotholomewConfig } from "../config/schemas.ts";
 import { getPromptsDir } from "../constants.ts";
 import type { Task } from "../tasks/schema.ts";
-import { parseContextFile } from "../utils/frontmatter.ts";
+import { parsePromptFile } from "../utils/frontmatter.ts";
 
 const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
@@ -36,37 +36,43 @@ export function extractKeywords(text: string): Set<string> {
  * Load persistent context files from prompts/ as a single formatted
  * string. Includes "always" files unconditionally and "contextual" files
  * whose content overlaps the provided taskKeywords.
+ *
+ * Validation is strict: any *.md file under prompts/ that fails the prompt
+ * frontmatter schema throws PromptValidationError naming the offending file.
+ * The only swallowed error is a missing prompts/ directory (e.g. fresh
+ * working dir before `botholomew init`).
  */
 export async function loadPersistentContext(
   projectDir: string,
   taskKeywords?: Set<string> | null,
 ): Promise<string> {
   const dir = getPromptsDir(projectDir);
-  let out = "";
-
+  let files: string[];
   try {
-    const files = await readdir(dir);
-    const mdFiles = files.filter((f) => f.endsWith(".md"));
-
-    for (const filename of mdFiles) {
-      const filePath = join(dir, filename);
-      const raw = await Bun.file(filePath).text();
-      const { meta, content } = parseContextFile(raw);
-
-      if (meta.loading === "always") {
-        out += `## ${filename}\n${content}\n\n`;
-      } else if (meta.loading === "contextual" && taskKeywords) {
-        const contentLower = content.toLowerCase();
-        const hasOverlap = [...taskKeywords].some((kw) =>
-          contentLower.includes(kw),
-        );
-        if (hasOverlap) {
-          out += `## ${filename} (contextual)\n${content}\n\n`;
-        }
+    files = await readdir(dir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return "";
+    throw err;
+  }
+  const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+
+  let out = "";
+  for (const filename of mdFiles) {
+    const filePath = join(dir, filename);
+    const raw = await Bun.file(filePath).text();
+    const { meta, content } = parsePromptFile(filePath, raw);
+
+    if (meta.loading === "always") {
+      out += `## ${filename}\n${content}\n\n`;
+    } else if (meta.loading === "contextual" && taskKeywords) {
+      const contentLower = content.toLowerCase();
+      const hasOverlap = [...taskKeywords].some((kw) =>
+        contentLower.includes(kw),
+      );
+      if (hasOverlap) {
+        out += `## ${filename} (contextual)\n${content}\n\n`;
       }
     }
-  } catch {
-    // prompts/ might not have md files yet
   }
 
   return out;

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) {
@@ -145,13 +149,22 @@ async function runClaimedTask(opts: {
     `Working: ${task.name}`,
   );
 
-  const systemPrompt = await buildSystemPrompt(
-    projectDir,
-    task,
-    dbPath,
-    config,
-    { hasMcpTools: mcpxClient != null },
-  );
+  let systemPrompt: string;
+  try {
+    systemPrompt = await buildSystemPrompt(projectDir, task, dbPath, config, {
+      hasMcpTools: mcpxClient != null,
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    await updateTaskStatus(projectDir, task.id, "failed", reason, null);
+    await logInteraction(projectDir, threadId, {
+      role: "system",
+      kind: "status_change",
+      content: `Task ${task.id} failed during prompt load: ${reason}`,
+    });
+    logger.error(`Task ${task.id} failed during prompt load: ${reason}`);
+    return;
+  }
 
   try {
     const result = await runAgentLoop({
@@ -161,6 +174,7 @@ async function runClaimedTask(opts: {
       dbPath,
       threadId,
       projectDir,
+      workerId,
       mcpxClient,
       callbacks,
     });