botholomew 0.7.0 → 0.7.2

package/README.md

@@ -6,4 +6,222 @@
   " "
 ```
 
-An AI agent for knowledge work.
+**A local-first AI agent for knowledge work.** Botholomew is a long-running
+autonomous agent that works its way through a task queue — reading email,
+summarizing documents, researching topics, organizing notes, and maintaining
+context over time — while you sleep, work, or chat with it.
+
+Unlike coding agents, Botholomew has **no shell, no filesystem, and no network
+tools** by default. Everything it touches lives inside a single DuckDB database
+at `.botholomew/data.duckdb` and a handful of markdown files. External access
+is granted deliberately, per project, through MCP servers.
+
+---
+
+## Why Botholomew?
+
+- **Autonomous.** A background daemon ticks on a schedule, claims tasks,
+  works them with Claude, and logs every interaction. You can close the
+  terminal and come back later.
+- **Portable.** Each project is a `.botholomew/` directory — markdown +
+  DuckDB. Copy it, share it, check it in (or `.gitignore` it).
+- **Local-first.** All data stays on your machine. Embeddings are indexed in
+  DuckDB's native vector store with HNSW. Model calls go direct to Anthropic
+  and OpenAI.
+- **Extensible.** External tools come from MCP servers via
+  [MCPX](https://github.com/evantahler/mcpx) — run them locally (Gmail,
+  Slack, GitHub) or connect through an MCP gateway like
+  [Arcade.dev](https://www.arcade.dev/) to reach hundreds of
+  authenticated services without managing each server yourself.
+  Reusable workflows are defined as markdown "skills" (slash commands).
+- **Safe by default.** The agent has no shell, no network, and no
+  filesystem access of its own. Everything it can touch lives in
+  `.botholomew/` — and every external capability is something you
+  explicitly add.
+- **Self-healing.** An OS-level watchdog (launchd on macOS, systemd on Linux)
+  restarts the daemon if it dies, rotates logs, and runs on boot.
+- **Self-modifying.** The agent maintains its own `beliefs.md` and
+  `goals.md` — it learns, updates its priors, and revises its goals as it
+  works.
+
+---
+
+## Install
+
+Requires [Bun](https://bun.sh) 1.1+.
+
+```bash
+bun install -g botholomew
+```
+
+Or run the dev build from a checkout:
+
+```bash
+git clone https://github.com/evantahler/botholomew
+cd botholomew
+bun install
+bun run dev -- --help
+```
+
+---
+
+## Quickstart
+
+```bash
+# 1. Initialize a project in the current directory
+botholomew init
+
+# 2. Add your API keys to .botholomew/config.json, or export env vars
+export ANTHROPIC_API_KEY=sk-ant-...
+export OPENAI_API_KEY=sk-...     # used for embeddings
+
+# 3. Queue some work
+botholomew task add "Summarize every markdown file in ~/notes"
+
+# 4. Start the daemon (foreground — watch it work)
+botholomew daemon start --foreground
+
+# 5. Or chat with the agent interactively
+botholomew chat
+```
+
+---
+
+## What a project looks like
+
+```
+my-project/
+  .botholomew/
+    soul.md               # always-loaded identity (not agent-editable)
+    beliefs.md            # always-loaded, agent-editable priors
+    goals.md              # always-loaded, agent-editable goals
+    config.json           # models, tick interval, API keys
+    data.duckdb           # tasks, schedules, context, embeddings, logs
+    mcpx/servers.json     # external MCP servers (Gmail, Slack, …)
+    skills/               # user-defined slash commands
+      summarize.md
+      standup.md
+    daemon.pid            # PID file for the running daemon
+    daemon.log            # rotating daemon logs
+```
+
+Everything the agent can touch is here. No surprises.
+
+---
+
+## The CLI
+
+| Command | Purpose |
+|---|---|
+| `botholomew init` | Create `.botholomew/` with templates and a fresh database |
+| `botholomew daemon start\|stop\|status` | Run, stop, or inspect the daemon |
+| `botholomew daemon install\|uninstall` | Register/remove the OS watchdog |
+| `botholomew daemon list` | List all Botholomew projects on this machine |
+| `botholomew chat` | Interactive Ink/React TUI |
+| `botholomew task list\|add\|view\|update\|reset\|delete` | Manage the task queue |
+| `botholomew schedule list\|add\|enable\|trigger\|delete` | Recurring work |
+| `botholomew context add\|list\|view\|search\|refresh\|remove` | Ingest & browse knowledge (files, folders, URLs) |
+| `botholomew mcpx add\|list\|tools\|test` | Configure external MCP servers |
+| `botholomew skill list\|show\|create` | Manage slash-command skills |
+| `botholomew file\|dir\|search ...` | Direct access to the agent's virtual filesystem |
+| `botholomew thread list\|view` | Browse the agent's interaction history |
+| `botholomew nuke context\|tasks\|schedules\|threads\|all` | Bulk-erase sections of the database |
+| `botholomew upgrade` | Self-update |
+
+---
+
+## How it works
+
+```
+ ┌──────────────┐         ┌──────────────┐         ┌──────────────┐
+ │    Chat      │         │   Daemon     │         │  Watchdog    │
+ │   (Ink TUI)  │         │  (tick loop) │         │ launchd/     │
+ │              │         │              │         │ systemd      │
+ └──────┬───────┘         └──────┬───────┘         └──────┬───────┘
+        │                        │                        │
+        │ enqueue tasks          │ claims tasks           │ every 60s:
+        │ browse history         │ runs LLM tool loops    │ check PID
+        │ invoke skills          │ updates status         │ restart if
+        │                        │ logs to threads        │ dead
+        │                        │                        │
+        └────────────┬───────────┴────────────┬───────────┘
+                     │                        │
+               ┌─────▼────────────────────────▼─────┐
+               │        DuckDB                       │
+               │  ┌───────────┐ ┌──────────────┐    │
+               │  │  tasks    │ │ context_items│    │
+               │  │ schedules │ │  embeddings  │    │
+               │  │  threads  │ │   (HNSW)     │    │
+               │  └───────────┘ └──────────────┘    │
+               └─────┬───────────────────────────────┘
+                     │
+                     ▼
+              MCPX ─► Gmail, Slack, GitHub, Firecrawl, …
+```
+
+See [docs/architecture.md](docs/architecture.md) for a deeper tour.
+
+---
+
+## Deep dives
+
+Topics worth understanding in detail:
+
+- **[Architecture](docs/architecture.md)** — daemon, chat, watchdog, and how
+  they share a database.
+- **[The virtual filesystem](docs/virtual-filesystem.md)** — why the agent's
+  "files" are actually DuckDB rows, and how `file_read`/`file_write` work.
+- **[Context & hybrid search](docs/context-and-search.md)** — LLM-driven
+  chunking, OpenAI embeddings, and DuckDB's HNSW-accelerated keyword +
+  vector search.
+- **[Tasks & schedules](docs/tasks-and-schedules.md)** — the claim loop, DAG
+  validation, stale-task recovery, and natural-language recurring schedules.
+- **[The Tool class](docs/tools.md)** — one Zod definition, three consumers
+  (Anthropic tool-use, Commander CLI, tests).
+- **[Persistent context](docs/persistent-context.md)** — `soul.md`,
+  `beliefs.md`, `goals.md`, frontmatter flags, and agent self-modification.
+- **[Skills (slash commands)](docs/skills.md)** — reusable prompt templates
+  with positional arguments and tab completion.
+- **[MCPX integration](docs/mcpx.md)** — configuring external servers and
+  how MCP tools are merged into the agent's toolset.
+- **[The watchdog](docs/watchdog.md)** — launchd plists, systemd units, and
+  multi-project service naming.
+- **[Configuration](docs/configuration.md)** — every key in `config.json`
+  and its default.
+
+---
+
+## Tech stack
+
+- **[Bun](https://bun.sh)** + TypeScript
+- **[DuckDB](https://duckdb.org)** via `@duckdb/node-api`, with the
+  **[VSS extension](https://duckdb.org/docs/stable/extensions/vss)** for
+  native vector search
+- **[Anthropic SDK](https://docs.anthropic.com/en/api/client-sdks)** for
+  Claude — the reasoning model
+- **OpenAI embeddings API** (`text-embedding-3-small`, 1536-dim) for
+  semantic search
+- **[MCPX](https://github.com/evantahler/mcpx)** for external tools
+- **[Ink 6](https://github.com/vadimdemedes/ink)** + **React 19** for the
+  terminal UI
+- **[Commander.js](https://github.com/tj/commander.js)** for the CLI
+- **[Zod](https://zod.dev)** for tool input/output schemas
+
+---
+
+## Contributing
+
+```bash
+bun install
+bun test
+bun run lint            # tsc --noEmit + biome check
+```
+
+See [CLAUDE.md](CLAUDE.md) for conventions (always use `bun`, bump the
+version in `package.json` on every merge to `main`, etc.).
+
+---
+
+## License
+
+MIT.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "An AI agent for knowledge work",
   "type": "module",
   "bin": {

package/src/chat/agent.ts

@@ -5,10 +5,16 @@ import type {
   ToolUseBlock,
 } from "@anthropic-ai/sdk/resources/messages";
 import type { BotholomewConfig } from "../config/schemas.ts";
+import { embedSingle } from "../context/embedder.ts";
 import { fitToContextWindow, getMaxInputTokens } from "../daemon/context.ts";
 import { maybeStoreResult } from "../daemon/large-results.ts";
-import { buildMetaHeader, loadPersistentContext } from "../daemon/prompt.ts";
+import {
+  buildMetaHeader,
+  extractKeywords,
+  loadPersistentContext,
+} from "../daemon/prompt.ts";
 import type { DbConnection } from "../db/connection.ts";
+import { hybridSearch } from "../db/embeddings.ts";
 import { logInteraction } from "../db/threads.ts";
 import { registerAllTools } from "../tools/registry.ts";
 import {
@@ -17,6 +23,7 @@ import {
   type ToolContext,
   toAnthropicTool,
 } from "../tools/tool.ts";
+import { logger } from "../utils/logger.ts";
 
 registerAllTools();
 
@@ -49,11 +56,44 @@ export function getChatTools() {
 
 export async function buildChatSystemPrompt(
   projectDir: string,
+  options?: {
+    keywordSource?: string;
+    conn?: DbConnection;
+    config?: Required<BotholomewConfig>;
+  },
 ): Promise<string> {
   const parts: string[] = [];
 
   parts.push(...buildMetaHeader(projectDir));
-  parts.push(...(await loadPersistentContext(projectDir)));
+
+  const keywordSource = options?.keywordSource?.trim();
+  const taskKeywords = keywordSource ? extractKeywords(keywordSource) : null;
+
+  parts.push(...(await loadPersistentContext(projectDir, taskKeywords)));
+
+  // Relevant context from embeddings search
+  const conn = options?.conn;
+  const config = options?.config;
+  if (conn && config?.openai_api_key && keywordSource) {
+    try {
+      const queryVec = await embedSingle(keywordSource, config);
+      const results = await hybridSearch(conn, keywordSource, queryVec, 5);
+
+      if (results.length > 0) {
+        parts.push("## Relevant Context");
+        for (const r of results) {
+          const path = r.source_path || r.context_item_id;
+          parts.push(`### ${r.title} (${path})`);
+          if (r.chunk_content) {
+            parts.push(r.chunk_content.slice(0, 1000));
+          }
+          parts.push("");
+        }
+      }
+    } catch (err) {
+      logger.debug(`Failed to load contextual embeddings: ${err}`);
+    }
+  }
 
   parts.push("## Instructions");
   parts.push(
@@ -95,6 +135,20 @@ export interface ChatTurnCallbacks {
   ) => void;
 }
 
+/**
+ * Walk messages backward to find the most recent human-authored user message.
+ * After tool turns, `messages[messages.length - 1]` is a user entry whose
+ * content is a `ToolResultBlockParam[]` — we want the string content from the
+ * actual user, not tool output, as the keyword source.
+ */
+function findLastUserText(messages: MessageParam[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role === "user" && typeof m.content === "string") return m.content;
+  }
+  return "";
+}
+
 /**
  * Run a single chat turn: stream the assistant response, execute any tool calls,
  * and loop until the model produces end_turn with no tool calls.
@@ -102,14 +156,14 @@ export interface ChatTurnCallbacks {
  */
 export async function runChatTurn(input: {
   messages: MessageParam[];
-  systemPrompt: string;
+  projectDir: string;
   config: Required<BotholomewConfig>;
   conn: DbConnection;
   threadId: string;
   toolCtx: ToolContext;
   callbacks: ChatTurnCallbacks;
 }): Promise<void> {
-  const { messages, systemPrompt, config, conn, threadId, toolCtx, callbacks } =
+  const { messages, projectDir, config, conn, threadId, toolCtx, callbacks } =
     input;
 
   const client = new Anthropic({
@@ -126,6 +180,18 @@ export async function runChatTurn(input: {
   for (let turn = 0; !maxTurns || turn < maxTurns; turn++) {
     const startTime = Date.now();
 
+    // 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
+    //       iteration is reflected in the next LLM call.
+    const keywordSource = findLastUserText(messages);
+    const systemPrompt = await buildChatSystemPrompt(projectDir, {
+      keywordSource,
+      conn,
+      config,
+    });
+
     fitToContextWindow(messages, systemPrompt, maxInputTokens);
     const stream = client.messages.stream({
       model: config.model,

package/src/chat/session.ts

@@ -17,11 +17,7 @@ import { loadSkills } from "../skills/loader.ts";
 import type { SkillDefinition } from "../skills/parser.ts";
 import type { ToolContext } from "../tools/tool.ts";
 import { generateThreadTitle } from "../utils/title.ts";
-import {
-  buildChatSystemPrompt,
-  type ChatTurnCallbacks,
-  runChatTurn,
-} from "./agent.ts";
+import { type ChatTurnCallbacks, runChatTurn } from "./agent.ts";
 
 export interface ChatSession {
   conn: DbConnection;
@@ -29,7 +25,6 @@ export interface ChatSession {
   projectDir: string;
   config: Required<BotholomewConfig>;
   messages: MessageParam[];
-  systemPrompt: string;
   toolCtx: ToolContext;
   skills: Map<string, SkillDefinition>;
   cleanup: () => Promise<void>;
@@ -83,8 +78,6 @@ export async function startChatSession(
     threadId = await createThread(conn, "chat_session", undefined, "New chat");
   }
 
-  const systemPrompt = await buildChatSystemPrompt(projectDir);
-
   const mcpxClient = await createMcpxClient(projectDir);
   const skills = await loadSkills(projectDir);
 
@@ -105,7 +98,6 @@ export async function startChatSession(
     projectDir,
     config,
     messages,
-    systemPrompt,
     toolCtx,
     skills,
     cleanup,
@@ -138,7 +130,7 @@ export async function sendMessage(
 
   await runChatTurn({
     messages: session.messages,
-    systemPrompt: session.systemPrompt,
+    projectDir: session.projectDir,
     config: session.config,
     conn: session.conn,
     threadId: session.threadId,

package/src/cli.ts

@@ -8,6 +8,7 @@ import { registerContextCommand } from "./commands/context.ts";
 import { registerDaemonCommand } from "./commands/daemon.ts";
 import { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
+import { registerNukeCommand } from "./commands/nuke.ts";
 import { registerPrepareCommand } from "./commands/prepare.ts";
 import { registerScheduleCommand } from "./commands/schedule.ts";
 import { registerSkillCommand } from "./commands/skill.ts";
@@ -40,6 +41,7 @@ registerChatCommand(program);
 registerContextCommand(program);
 registerMcpxCommand(program);
 registerSkillCommand(program);
+registerNukeCommand(program);
 registerPrepareCommand(program);
 registerCheckUpdateCommand(program);
 registerUpgradeCommand(program);

package/src/commands/chat.ts

@@ -12,7 +12,7 @@ export function registerChatCommand(program: Command) {
         "  Commands:\n" +
         "    /help           Show keyboard shortcuts\n" +
         "    /tools          Open tool call inspector\n" +
-        "    /quit, /exit    End the chat session",
+        "    /exit           End the chat session",
     )
     .option("--thread-id <id>", "Resume an existing chat thread")
     .option("-p, --prompt <text>", "Start chat with an initial prompt")

package/src/commands/nuke.ts

@@ -0,0 +1,149 @@
+import ansis from "ansis";
+import type { Command } from "commander";
+import type { DbConnection } from "../db/connection.ts";
+import { deleteAllContextItems } from "../db/context.ts";
+import { deleteAllDaemonState } from "../db/daemon-state.ts";
+import { deleteAllSchedules } from "../db/schedules.ts";
+import { deleteAllTasks } from "../db/tasks.ts";
+import { deleteAllThreads } from "../db/threads.ts";
+import { logger } from "../utils/logger.ts";
+import { getDaemonStatus } from "../utils/pid.ts";
+import { withDb } from "./with-db.ts";
+
+type NukeScope = "context" | "tasks" | "schedules" | "threads" | "all";
+
+const TABLES_BY_SCOPE: Record<NukeScope, string[]> = {
+  context: ["context_items", "embeddings"],
+  tasks: ["tasks"],
+  schedules: ["schedules"],
+  threads: ["threads", "interactions"],
+  all: [
+    "context_items",
+    "embeddings",
+    "tasks",
+    "schedules",
+    "threads",
+    "interactions",
+    "daemon_state",
+  ],
+};
+
+async function countRows(conn: DbConnection, table: string): Promise<number> {
+  const row = await conn.queryGet<{ cnt: number }>(
+    `SELECT COUNT(*) AS cnt FROM ${table}`,
+  );
+  return row ? Number(row.cnt) : 0;
+}
+
+function printDryRun(scope: NukeScope, counts: Record<string, number>) {
+  console.log(ansis.red.bold(`Nuke scope: ${scope}`));
+  console.log("Would delete:");
+  const nameWidth = Math.max(...Object.keys(counts).map((k) => k.length));
+  for (const [table, count] of Object.entries(counts)) {
+    const padded = table.padEnd(nameWidth + 2);
+    console.log(`  ${padded}${ansis.dim(`${count} rows`)}`);
+  }
+  console.log("");
+  console.log(
+    ansis.yellow("Re-run with --yes to confirm. This cannot be undone."),
+  );
+}
+
+async function ensureDaemonStopped(dir: string): Promise<boolean> {
+  const status = await getDaemonStatus(dir);
+  if (status) {
+    logger.error(
+      `Daemon is running (PID ${status.pid}). Stop it first: botholomew daemon stop`,
+    );
+    return false;
+  }
+  return true;
+}
+
+async function runNuke(conn: DbConnection, scope: NukeScope): Promise<void> {
+  // Not wrapped in a transaction: DuckDB's FK index checks on DELETE FROM
+  // threads inside a transaction see stale interactions rows even after
+  // DELETE FROM interactions ran in the same transaction. Each helper is
+  // already a small sequence of statements, so auto-commit is fine for a
+  // destructive dev-time tool.
+  if (scope === "context" || scope === "all") {
+    const { contextItems, embeddings } = await deleteAllContextItems(conn);
+    logger.success(
+      `Deleted ${contextItems} context_items, ${embeddings} embeddings`,
+    );
+  }
+  if (scope === "tasks" || scope === "all") {
+    const n = await deleteAllTasks(conn);
+    logger.success(`Deleted ${n} tasks`);
+  }
+  if (scope === "schedules" || scope === "all") {
+    const n = await deleteAllSchedules(conn);
+    logger.success(`Deleted ${n} schedules`);
+  }
+  if (scope === "threads" || scope === "all") {
+    const { threads, interactions } = await deleteAllThreads(conn);
+    logger.success(`Deleted ${threads} threads, ${interactions} interactions`);
+  }
+  if (scope === "all") {
+    const n = await deleteAllDaemonState(conn);
+    logger.success(`Deleted ${n} daemon_state entries`);
+  }
+}
+
+function registerScope(
+  program: Command,
+  parent: Command,
+  scope: NukeScope,
+  description: string,
+) {
+  parent
+    .command(scope)
+    .description(description)
+    .option("-y, --yes", "confirm the deletion (required)")
+    .action((opts) =>
+      withDb(program, async (conn, dir) => {
+        if (!(await ensureDaemonStopped(dir))) {
+          process.exit(1);
+        }
+        const tables = TABLES_BY_SCOPE[scope];
+        const counts: Record<string, number> = {};
+        for (const t of tables) {
+          counts[t] = await countRows(conn, t);
+        }
+
+        if (!opts.yes) {
+          printDryRun(scope, counts);
+          process.exit(1);
+        }
+
+        await runNuke(conn, scope);
+      }),
+    );
+}
+
+export function registerNukeCommand(program: Command) {
+  const nuke = program
+    .command("nuke")
+    .description("Bulk-erase sections of the database");
+
+  registerScope(
+    program,
+    nuke,
+    "context",
+    "Erase all context_items and embeddings",
+  );
+  registerScope(program, nuke, "tasks", "Erase all tasks");
+  registerScope(program, nuke, "schedules", "Erase all schedules");
+  registerScope(
+    program,
+    nuke,
+    "threads",
+    "Erase all threads and interactions (daemon + chat history)",
+  );
+  registerScope(
+    program,
+    nuke,
+    "all",
+    "Erase everything in the database (preserves schema, skills, and on-disk soul/beliefs/goals)",
+  );
+}

package/src/commands/skill.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import ansis from "ansis";
 import type { Command } from "commander";
 import { getSkillsDir } from "../constants.ts";
@@ -24,6 +24,67 @@ export function registerSkillCommand(program: Command) {
       }
     });
 
+  skill
+    .command("list")
+    .description("List all skills loaded from .botholomew/skills/")
+    .action(async () => {
+      const dir = program.opts().dir;
+      const skills = await loadSkills(dir);
+
+      if (skills.size === 0) {
+        logger.dim("No skill files found.");
+        return;
+      }
+
+      const sorted = [...skills.values()].sort((a, b) =>
+        a.name.localeCompare(b.name),
+      );
+
+      const header = `${ansis.bold("Name".padEnd(20))} ${ansis.bold("Description".padEnd(40))} ${ansis.bold("Args".padEnd(20))} ${ansis.bold("Path")}`;
+      console.log(header);
+      console.log("-".repeat(header.length));
+
+      for (const s of sorted) {
+        const name = s.name.padEnd(20);
+        const desc = s.description
+          ? s.description.slice(0, 39).padEnd(40)
+          : ansis.dim("(no description)".padEnd(40));
+        const args =
+          s.arguments.length > 0
+            ? s.arguments
+                .map((a) => a.name)
+                .join(",")
+                .slice(0, 19)
+                .padEnd(20)
+            : ansis.dim("none".padEnd(20));
+        const path = relative(dir, s.filePath);
+        console.log(`${name} ${desc} ${args} ${path}`);
+      }
+
+      console.log(`\n${ansis.dim(`${sorted.length} skill(s)`)}`);
+    });
+
+  skill
+    .command("show <name>")
+    .description("Print the raw contents of a skill file")
+    .action(async (name: string) => {
+      const dir = program.opts().dir;
+      const skills = await loadSkills(dir);
+      const s = skills.get(name.toLowerCase());
+
+      if (!s) {
+        logger.error(`Skill not found: ${name}`);
+        if (skills.size > 0) {
+          const available = [...skills.keys()].sort().join(", ");
+          console.error(ansis.dim(`Available: ${available}`));
+        }
+        process.exit(1);
+      }
+
+      const raw = await Bun.file(s.filePath).text();
+      process.stdout.write(raw);
+    });
+
   skill
     .command("create <name>")
     .description("Create a new skill file from a template")

package/src/daemon/prompt.ts

@@ -13,6 +13,21 @@ const pkg = await Bun.file(
   new URL("../../package.json", import.meta.url),
 ).json();
 
+/**
+ * Extract keyword set from free-form text: lowercase, split on whitespace,
+ * keep words longer than 3 chars. Used to match `loading: contextual` files
+ * against the agent's current intent (task text for the daemon, latest user
+ * message for the chat).
+ */
+export function extractKeywords(text: string): Set<string> {
+  return new Set(
+    text
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 3),
+  );
+}
+
 /**
  * Load persistent context files from .botholomew/ directory.
  * Returns an array of formatted string sections for "always" loaded files.
@@ -85,12 +100,7 @@ export async function buildSystemPrompt(
 
   // Build keyword set from task for contextual loading
   const taskKeywords = task
-    ? new Set(
-        `${task.name} ${task.description}`
-          .toLowerCase()
-          .split(/\s+/)
-          .filter((w) => w.length > 3),
-      )
+    ? extractKeywords(`${task.name} ${task.description}`)
     : null;
 
   // Load context files from .botholomew/