botholomew 0.22.2 → 0.23.0

package/README.md

@@ -236,6 +236,7 @@ semantic search, append-only versioning, and URL refresh all live there.
 | `botholomew worker run\|start` | Run a worker (foreground or background); `--persist` for long-running, `--task-id <id>` to target one task |
 | `botholomew worker list\|status\|stop\|kill\|reap` | Inspect and manage running workers |
 | `botholomew chat` | Interactive Ink/React TUI |
+| `botholomew dream` | Reflect on recent threads — consolidate learnings into the knowledge store and update beliefs/goals (`--since`, `--dry-run`); also `/dream` in chat |
 | `botholomew task list\|add\|view\|update\|reset\|delete` | Manage the task queue (markdown files in `tasks/`) |
 | `botholomew schedule list\|add\|view\|enable\|disable\|trigger\|delete` | Recurring work (markdown files in `schedules/`) |
 | `botholomew membot add\|ls\|tree\|read\|write\|search\|info\|versions\|diff\|refresh\|…` | Knowledge-store passthrough to [`membot`](https://github.com/evantahler/membot) — `--config` is resolved from `membot_scope` (default `~/.membot`) |
@@ -244,7 +245,7 @@ semantic search, append-only versioning, and URL refresh all live there.
 | `botholomew prompts list\|show\|create\|edit\|delete\|validate` | CRUD over the markdown files in `prompts/` (with strict frontmatter validation) |
 | `botholomew mcpx servers\|list\|add\|remove\|info\|search\|exec\|ping\|auth\|deauth\|import-global\|…` | Configure external MCP servers (passthrough to `mcpx`) |
 | `botholomew skill list\|show\|create\|validate` | Manage slash-command skills |
-| `botholomew thread list\|view` | Browse the agent's conversation history (CSVs in `threads/`) |
+| `botholomew thread list\|view\|search\|delete\|follow` | Browse and search the agent's conversation history (CSVs in `threads/`) |
 | `botholomew nuke knowledge\|tasks\|schedules\|threads\|all` | Bulk-erase project state |
 | `botholomew upgrade` | Self-update |
 
@@ -313,6 +314,9 @@ Topics worth understanding in detail:
   (Anthropic tool-use, Commander CLI, tests).
 - **[Prompts](docs/prompts.md)** — generic markdown files in `prompts/`,
   strict frontmatter validation, and full CRUD via CLI + agent tools.
+- **[Reflection (dream)](docs/reflection.md)** — `botholomew dream` / `/dream`:
+  consolidating recent threads into durable memory and self-edited prompts,
+  plus episodic `thread search`.
 - **[Skills (slash commands)](docs/skills.md)** — reusable prompt templates
   with positional arguments and tab completion; the chat agent can also
   create, edit, and search them at runtime.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botholomew",
-  "version": "0.22.2",
+  "version": "0.23.0",
   "description": "An autonomous AI agent for knowledge work — works your task queue while you sleep.",
   "type": "module",
   "bin": {
@@ -21,6 +21,7 @@
     "dev:demo": "bun run src/cli.ts chat -p 'learn everything you can about me from the connected MCP services and then save what you'\\''ve learned about me to context'",
     "test": "bun test",
     "lint": "tsc --noEmit && biome check .",
+    "format": "biome check --write .",
     "build": "bun run scripts/build.ts",
     "capture": "bun run scripts/capture.ts",
     "docs:dev": "vitepress dev docs",

package/src/chat/dream-prompt.ts

@@ -0,0 +1,20 @@
+/**
+ * The reflection ("dream") instructions. Shared by the built-in `/dream` chat
+ * command and the `botholomew dream` CLI so both run the exact same
+ * consolidation. The CLI appends a precise time window (and, for `--dry-run`,
+ * a propose-only directive) after this body.
+ *
+ * This is intentionally a built-in constant — not a seeded `skills/*.md` file —
+ * so reflection behaves consistently and can't be silently broken by edits.
+ */
+export const DREAM_PROMPT_BODY = `You are about to *dream*: review your recent conversations and consolidate what you learned into durable memory.
+
+Work through these steps, using your existing tools:
+
+1. **Recall.** Use \`list_threads\` and \`search_threads\` to find recent conversations (chat sessions and worker ticks), then \`view_thread\` to read the ones that look substantive. Focus on the most recent window — by default the last day or so, or everything since your most recent prior reflection (look for \`reflections/\` in the knowledge store with \`membot_tree\`).
+
+2. **Distill.** Pull out the durable facts, decisions, outcomes, and preferences worth keeping — not the chatter. Write a concise reflection into the knowledge store at \`reflections/<UTC-date>.md\` (e.g. \`reflections/2026-06-07.md\`) using \`membot_write\`. Note the project these came from so reflections from different projects don't blur together. Store genuinely reusable facts under their natural \`logical_path\` too, not only in the reflection log.
+
+3. **Self-edit.** Read \`prompts/goals.md\` and \`prompts/beliefs.md\` with \`prompt_read\`. If your recent work justifies it, apply focused updates with \`prompt_edit\` (git-style line patches) — add a newly learned belief, mark a goal done, refine a stale one. Make small, well-justified edits; don't rewrite wholesale. \`prompt_edit\` refuses files marked \`agent-modification: false\`, which is fine — skip them.
+
+4. **Report.** Finish with a short audit summary: which threads you reviewed, what you stored in the knowledge store, and which prompt edits you made (or chose not to make).`;

package/src/chat/session.ts

@@ -46,7 +46,7 @@ export function abortActiveStream(session: ChatSession): boolean {
   return false;
 }
 
-function requireProviderCreds(config: BotholomewConfig): void {
+export function requireProviderCreds(config: BotholomewConfig): void {
   const { llm } = config;
   if (llm.provider === "anthropic" && !llm.api_key) {
     throw new BotholomewLlmError(

package/src/cli.ts

@@ -5,6 +5,7 @@ import { program } from "commander";
 import { registerCapabilitiesCommand } from "./commands/capabilities.ts";
 import { registerChatCommand } from "./commands/chat.ts";
 import { registerCheckUpdateCommand } from "./commands/check-update.ts";
+import { registerDreamCommand } from "./commands/dream.ts";
 import { registerInitCommand } from "./commands/init.ts";
 import { registerMcpxCommand } from "./commands/mcpx.ts";
 import { registerMembotCommand } from "./commands/membot.ts";
@@ -64,6 +65,7 @@ registerTaskCommand(program);
 registerThreadCommand(program);
 registerScheduleCommand(program);
 registerChatCommand(program);
+registerDreamCommand(program);
 registerMembotCommand(program);
 registerCapabilitiesCommand(program);
 registerPromptsCommand(program);

package/src/commands/chat.ts

@@ -21,6 +21,7 @@ export function registerChatCommand(program: Command) {
         "  Slash commands:\n" +
         "    /help           Show chat-command reference (Help tab has the full keymap)\n" +
         "    /skills         List available skills\n" +
+        "    /dream          Reflect on recent threads — consolidate learnings, update beliefs/goals\n" +
         "    /clear          End current thread and start a new one\n" +
         "    /exit           End the chat session",
     )

package/src/commands/dream.ts

@@ -0,0 +1,194 @@
+import type { LanguageModel } from "ai";
+import ansis from "ansis";
+import type { Command } from "commander";
+import { type ChatTurnCallbacks, runChatTurn } from "../chat/agent.ts";
+import { DREAM_PROMPT_BODY } from "../chat/dream-prompt.ts";
+import { requireProviderCreds } from "../chat/session.ts";
+import { loadConfig } from "../config/loader.ts";
+import { createMcpxClient, resolveMcpxDir } from "../mcpx/client.ts";
+import type { WithMem } from "../mem/client.ts";
+import {
+  createThread,
+  endThread,
+  ensureThreadsDir,
+  logInteraction,
+} from "../threads/store.ts";
+import { logger } from "../utils/logger.ts";
+import { utcDateString } from "../utils/v7-date.ts";
+
+/** Gray `HH:MM:SS` stamp, matching the logger's line prefix. */
+function ts(): string {
+  return ansis.gray(new Date().toTimeString().slice(0, 8));
+}
+
+/** Collapse a tool-input blob to a single readable line. */
+function previewInput(input: string, max = 100): string {
+  const oneLine = input.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max)}…` : oneLine;
+}
+
+export interface DreamOptions {
+  /** ISO date or relative duration (`24h`, `7d`). Defaults to `dream_lookback_hours`. */
+  since?: string;
+  /** Propose edits without writing anything. */
+  dryRun?: boolean;
+  /** Test seam: inject a language model + membot accessor. */
+  _testModel?: LanguageModel;
+  _testWithMem?: WithMem;
+}
+
+const RELATIVE_RE = /^(\d+)\s*([hd])$/i;
+
+/**
+ * Resolve the start of the recall window. Accepts a relative duration
+ * (`24h`, `7d`), an ISO date, or — when omitted — `now - lookbackHours`.
+ */
+export function resolveSince(
+  since: string | undefined,
+  lookbackHours: number,
+  now: Date,
+): Date {
+  if (!since) {
+    return new Date(now.getTime() - lookbackHours * 3600_000);
+  }
+  const rel = RELATIVE_RE.exec(since.trim());
+  if (rel) {
+    const n = Number(rel[1]);
+    const unitHours = rel[2]?.toLowerCase() === "d" ? 24 : 1;
+    return new Date(now.getTime() - n * unitHours * 3600_000);
+  }
+  const parsed = new Date(since);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(
+      `Could not parse --since "${since}". Use an ISO date (2026-06-01) or a relative duration like 24h / 7d.`,
+    );
+  }
+  return parsed;
+}
+
+/**
+ * Run one reflection ("dream") pass: review recent threads, consolidate
+ * durable facts into the knowledge store, and (unless `--dry-run`) apply
+ * justified edits to the agent's prompt files. Reuses the chat agent loop and
+ * its tool set, so this composes the existing primitives — no new machinery.
+ * Returns the audit thread id.
+ */
+export async function runDream(
+  projectDir: string,
+  opts: DreamOptions = {},
+): Promise<string> {
+  const config = await loadConfig(projectDir);
+  requireProviderCreds(config);
+  await ensureThreadsDir(projectDir);
+
+  const now = new Date();
+  const since = resolveSince(opts.since, config.dream_lookback_hours, now);
+
+  const threadId = await createThread(
+    projectDir,
+    "chat_session",
+    undefined,
+    `Dream — ${utcDateString(now)}`,
+  );
+
+  const windowLine = `Scope your recall to conversations from ${since.toISOString()} onward (it is now ${now.toISOString()}).`;
+  const dryRunLine = opts.dryRun
+    ? "\n\nIMPORTANT — DRY RUN: Do NOT call `prompt_edit` or any `membot` write tool. Instead, end with a report describing the reflection you would store and the exact prompt edits you would propose, then stop."
+    : "";
+  const userMessage = `${DREAM_PROMPT_BODY}\n\n${windowLine}${dryRunLine}`;
+
+  await logInteraction(projectDir, threadId, {
+    role: "user",
+    kind: "message",
+    content: userMessage,
+  });
+
+  logger.info(
+    `${ansis.magenta.bold("Dreaming")} — reviewing threads since ${ansis.cyan(
+      since.toISOString(),
+    )}${opts.dryRun ? ` ${ansis.yellow("(dry run)")}` : ""}`,
+  );
+
+  const mcpxClient = await createMcpxClient(resolveMcpxDir(projectDir, config));
+
+  // Chat callbacks don't carry tool durations, so time each call by id.
+  const toolStartedAt = new Map<string, number>();
+  let midStream = false;
+
+  const callbacks: ChatTurnCallbacks = {
+    onToken: (text) => {
+      process.stdout.write(text);
+      midStream = true;
+    },
+    onToolStart: (id, name, input) => {
+      if (midStream) {
+        process.stdout.write("\n");
+        midStream = false;
+      }
+      toolStartedAt.set(id, Date.now());
+      process.stdout.write(
+        `${ts()} ${ansis.yellow("▶")} ${ansis.bold(name)} ${ansis.dim(
+          previewInput(input),
+        )}\n`,
+      );
+    },
+    onToolEnd: (id, name, _output, isError) => {
+      const startedAt = toolStartedAt.get(id);
+      const elapsed = startedAt
+        ? ` ${ansis.dim(`(${((Date.now() - startedAt) / 1000).toFixed(1)}s)`)}`
+        : "";
+      toolStartedAt.delete(id);
+      const mark = isError ? ansis.red("✗") : ansis.green("✓");
+      const status = isError ? ` ${ansis.red("error")}` : "";
+      process.stdout.write(
+        `${ts()} ${mark} ${ansis.bold(name)}${status}${elapsed}\n`,
+      );
+    },
+  };
+
+  try {
+    await runChatTurn({
+      messages: [{ role: "user", content: userMessage }],
+      projectDir,
+      config,
+      threadId,
+      mcpxClient,
+      callbacks,
+      _testModel: opts._testModel,
+      _testWithMem: opts._testWithMem,
+    });
+  } finally {
+    process.stdout.write("\n");
+    await endThread(projectDir, threadId);
+    await mcpxClient?.close();
+  }
+
+  return threadId;
+}
+
+export function registerDreamCommand(program: Command) {
+  program
+    .command("dream")
+    .description(
+      "Reflect on recent threads: consolidate durable facts into the knowledge store and update beliefs/goals",
+    )
+    .option(
+      "-s, --since <when>",
+      "ISO date or relative duration (24h, 7d) to scope recall (default: dream_lookback_hours)",
+    )
+    .option(
+      "--dry-run",
+      "propose edits without writing prompts or the knowledge store",
+      false,
+    )
+    .action(async (opts: { since?: string; dryRun?: boolean }) => {
+      const dir = program.opts().dir;
+      const threadId = await runDream(dir, {
+        since: opts.since,
+        dryRun: opts.dryRun,
+      });
+      logger.success(
+        `Dream complete — audit with ${ansis.cyan(`botholomew thread view ${threadId}`)}`,
+      );
+    });
+}

package/src/commands/status.ts

@@ -22,10 +22,6 @@ function formatAge(fromIso: string | null, to = new Date()): string {
   return `${Math.floor(hours / 24)}d ago`;
 }
 
-function padColored(colored: string, raw: string, width: number): string {
-  return colored + " ".repeat(Math.max(0, width - raw.length));
-}
-
 function workerStatusColor(status: WorkerStatus): string {
   switch (status) {
     case "running":

package/src/commands/thread.ts

@@ -6,9 +6,12 @@ import {
   getInteractionsAfter,
   getThread,
   type Interaction,
+  type InteractionRole,
   isThreadEnded,
   listThreads,
+  searchThreads,
   type Thread,
+  type ThreadType,
 } from "../threads/store.ts";
 import { logger } from "../utils/logger.ts";
 
@@ -39,6 +42,67 @@ export function registerThreadCommand(program: Command) {
       }
     });
 
+  thread
+    .command("search <query>")
+    .description("Search past conversations for a regex (or plain substring)")
+    .option("--ignore-case", "case-insensitive match (default true)", true)
+    .option("--no-ignore-case", "case-sensitive match")
+    .option(
+      "-r, --role <role>",
+      "filter by role (user, assistant, system, tool)",
+    )
+    .option("-t, --type <type>", "filter by type (worker_tick, chat_session)")
+    .option("--since <iso>", "only threads started on or after this ISO date")
+    .option("--until <iso>", "only threads started on or before this ISO date")
+    .option("-l, --limit <n>", "max hits to return", Number.parseInt)
+    .action(
+      async (
+        query: string,
+        opts: {
+          ignoreCase?: boolean;
+          role?: string;
+          type?: string;
+          since?: string;
+          until?: string;
+          limit?: number;
+        },
+      ) => {
+        const dir = program.opts().dir;
+        let regex: RegExp;
+        try {
+          regex = new RegExp(query, opts.ignoreCase === false ? "" : "i");
+        } catch (err) {
+          logger.error(
+            `Invalid regex: ${err instanceof Error ? err.message : String(err)}`,
+          );
+          process.exit(1);
+        }
+        const { hits, threadsScanned } = await searchThreads(dir, {
+          regex,
+          role: opts.role as InteractionRole | undefined,
+          type: opts.type as ThreadType | undefined,
+          since: opts.since ? new Date(opts.since) : undefined,
+          until: opts.until ? new Date(opts.until) : undefined,
+          maxResults: opts.limit,
+        });
+
+        if (hits.length === 0) {
+          logger.dim(`No hits in ${threadsScanned} thread(s).`);
+          return;
+        }
+
+        for (const h of hits) {
+          const id = ansis.dim(h.thread_id);
+          const seq = ansis.dim(`#${h.sequence}`);
+          const snippet = h.content_snippet.replace(/\n/g, " ");
+          console.log(`  ${id}  ${seq}  ${roleColor(h.role)}  ${snippet}`);
+        }
+        logger.dim(
+          `\n${hits.length} hit(s) in ${threadsScanned} thread(s). View context: botholomew thread view <id>`,
+        );
+      },
+    );
+
   thread
     .command("view <id>")
     .description("View thread details and interactions")

package/src/config/schemas.ts

@@ -30,6 +30,8 @@ export interface BotholomewConfig {
   schedule_min_interval_seconds: number;
   schedule_claim_stale_seconds: number;
   tui_idle_timeout_seconds: number;
+  /** Default window (in hours) of recent threads the `dream` reflection reviews when `--since` is omitted. */
+  dream_lookback_hours: number;
   log_level: string;
   membot_scope: Scope;
   mcpx_scope: Scope;
@@ -65,6 +67,7 @@ export const DEFAULT_CONFIG: BotholomewConfig = {
   schedule_min_interval_seconds: 60,
   schedule_claim_stale_seconds: 300,
   tui_idle_timeout_seconds: 180,
+  dream_lookback_hours: 24,
   log_level: "",
   membot_scope: "global",
   mcpx_scope: "global",

package/src/skills/commands.ts

@@ -1,3 +1,4 @@
+import { DREAM_PROMPT_BODY } from "../chat/dream-prompt.ts";
 import type { SkillDefinition } from "./parser.ts";
 import { renderSkill, tokenizeForSkill, validateSkillArgs } from "./parser.ts";
 
@@ -10,6 +11,11 @@ export interface SlashCommand {
 export const BUILTIN_SLASH_COMMANDS: SlashCommand[] = [
   { name: "help", description: "Show command reference and shortcuts" },
   { name: "skills", description: "List available skills" },
+  {
+    name: "dream",
+    description:
+      "Reflect on recent threads: consolidate learnings and update beliefs/goals",
+  },
   { name: "clear", description: "End current thread and start a new one" },
   { name: "exit", description: "End the chat session" },
 ];
@@ -120,6 +126,14 @@ export function handleSlashCommand(
     return true;
   }
 
+  if (name === "dream") {
+    // Built-in (not a user-editable skill) so reflection behaves consistently.
+    // Queue the reflection prompt as a normal user message — the chat agent
+    // already has every tool it needs (thread search, membot, prompt_edit).
+    ctx.queueUserMessage(DREAM_PROMPT_BODY, { display: input });
+    return true;
+  }
+
   if (name === "skills") {
     if (ctx.skills.size === 0) {
       ctx.addSystemMessage("No skills loaded. Add .md files to skills/");

package/src/tasks/store.ts

@@ -302,7 +302,7 @@ export async function resetStaleTasks(
   const reset: string[] = [];
   for (const id of ids) {
     const t = await getTask(projectDir, id);
-    if (!t || t.status !== "in_progress") continue;
+    if (t?.status !== "in_progress") continue;
     const claimedAt = t.claimed_at ? Date.parse(t.claimed_at) : Date.now();
     if (claimedAt >= cutoff) continue;
     const fm: TaskFrontmatter = {
@@ -365,7 +365,7 @@ export async function claimSpecificTask(
   workerId: string,
 ): Promise<Task | null> {
   const t = await getTask(projectDir, id);
-  if (!t || t.status !== "pending") return null;
+  if (t?.status !== "pending") return null;
   return tryClaim(projectDir, id, workerId);
 }
 
@@ -383,7 +383,7 @@ async function tryClaim(
   }
   try {
     const t = await getTask(projectDir, id);
-    if (!t || t.status !== "pending") {
+    if (t?.status !== "pending") {
       await releaseLock(lockPath);
       return null;
     }
@@ -427,7 +427,7 @@ async function isUnblocked(projectDir: string, t: Task): Promise<boolean> {
   if (t.blocked_by.length === 0) return true;
   for (const blockerId of t.blocked_by) {
     const blocker = await getTask(projectDir, blockerId);
-    if (!blocker || blocker.status !== "complete") return false;
+    if (blocker?.status !== "complete") return false;
   }
   return true;
 }

package/src/threads/store.ts

@@ -456,6 +456,108 @@ export async function listThreads(
   return out.slice(offset, offset + limit);
 }
 
+export interface ThreadSearchHit {
+  thread_id: string;
+  thread_title: string;
+  thread_type: ThreadType;
+  /** 1-based sequence of the matching interaction. Plug into `view_thread({ id, offset: sequence-1 })`. */
+  sequence: number;
+  role: InteractionRole;
+  kind: InteractionKind;
+  content_snippet: string;
+  created_at: Date;
+}
+
+export interface ThreadSearchOptions {
+  /** Compiled regex matched against content, tool_name, and tool_input. */
+  regex: RegExp;
+  role?: InteractionRole;
+  kind?: InteractionKind;
+  type?: ThreadType;
+  /** Only consider threads started on or after this date. */
+  since?: Date;
+  /** Only consider threads started on or before this date. */
+  until?: Date;
+  /** Maximum number of hits to return across all threads. */
+  maxResults?: number;
+}
+
+/**
+ * Scan past conversations for a regex match. Shared by the `search_threads`
+ * agent tool and the `botholomew thread search` CLI so both stay in lockstep.
+ * Returns hits with `(thread_id, sequence)` pairs and the count of threads
+ * actually opened.
+ */
+export async function searchThreads(
+  projectDir: string,
+  opts: ThreadSearchOptions,
+): Promise<{ hits: ThreadSearchHit[]; threadsScanned: number }> {
+  const sinceMs = opts.since ? opts.since.getTime() : Number.NEGATIVE_INFINITY;
+  const untilMs = opts.until ? opts.until.getTime() : Number.POSITIVE_INFINITY;
+  const maxResults = opts.maxResults ?? 20;
+
+  const threads = await listThreads(projectDir, { type: opts.type });
+  const hits: ThreadSearchHit[] = [];
+  let scanned = 0;
+
+  for (const t of threads) {
+    const startedMs = t.started_at.getTime();
+    if (startedMs < sinceMs || startedMs > untilMs) continue;
+    const data = await getThread(projectDir, t.id);
+    if (!data) continue;
+    scanned++;
+    for (const ix of data.interactions) {
+      if (opts.role && ix.role !== opts.role) continue;
+      if (opts.kind && ix.kind !== opts.kind) continue;
+      if (!matchInteraction(ix, opts.regex)) continue;
+      hits.push({
+        thread_id: t.id,
+        thread_title: t.title || "(untitled)",
+        thread_type: t.type,
+        sequence: ix.sequence,
+        role: ix.role,
+        kind: ix.kind,
+        content_snippet: snippetForMatch(ix.content, opts.regex),
+        created_at: ix.created_at,
+      });
+      if (hits.length >= maxResults) break;
+    }
+    if (hits.length >= maxResults) break;
+  }
+
+  return { hits, threadsScanned: scanned };
+}
+
+const SNIPPET_MAX = 240;
+
+function matchInteraction(ix: Interaction, regex: RegExp): boolean {
+  // We treat the user-visible content as the primary haystack, but a
+  // tool_use interaction's content is just "Calling <name>" — fall through
+  // to the tool name + JSON args so a search for an exact tool argument
+  // still finds the call.
+  if (regex.test(ix.content)) return true;
+  if (ix.tool_name && regex.test(ix.tool_name)) return true;
+  if (ix.tool_input && regex.test(ix.tool_input)) return true;
+  return false;
+}
+
+/**
+ * Pick a short window around the first regex match so callers get enough
+ * context to know whether the hit is relevant without paging the whole
+ * interaction. Falls back to the head when the match index isn't available.
+ */
+function snippetForMatch(content: string, regex: RegExp): string {
+  const m = regex.exec(content);
+  if (!m) return content.slice(0, SNIPPET_MAX);
+  const idx = m.index;
+  const start = Math.max(0, idx - 60);
+  const end = Math.min(content.length, idx + SNIPPET_MAX - 60);
+  let snippet = content.slice(start, end);
+  if (start > 0) snippet = `…${snippet}`;
+  if (end < content.length) snippet = `${snippet}…`;
+  return snippet;
+}
+
 // ---------------------------------------------------------------------------
 // internals
 // ---------------------------------------------------------------------------

package/src/tools/skill/write.ts

@@ -30,7 +30,7 @@ const inputSchema = z.object({
   name: z
     .string()
     .describe(
-      "Skill name (slash-command identifier). Will be normalized to lowercase + [a-z0-9-]. Reserved: help, skills, clear, exit.",
+      "Skill name (slash-command identifier). Will be normalized to lowercase + [a-z0-9-]. Reserved: help, skills, dream, clear, exit.",
     ),
   description: z
     .string()
@@ -67,7 +67,7 @@ const outputSchema = z.object({
 export const skillWriteTool = {
   name: "skill_write",
   description:
-    "[[ bash equivalent command: tee ]] Create or overwrite a skill file (user-defined slash command) at skills/<name>.md. Fails with path_conflict when the file exists unless on_conflict='overwrite'. Reserved names (help, skills, clear, exit) are rejected. The generated file is parsed to validate before being written.",
+    "[[ bash equivalent command: tee ]] Create or overwrite a skill file (user-defined slash command) at skills/<name>.md. Fails with path_conflict when the file exists unless on_conflict='overwrite'. Reserved names (help, skills, dream, clear, exit) are rejected. The generated file is parsed to validate before being written.",
   group: "skill",
   inputSchema,
   outputSchema,
@@ -78,7 +78,7 @@ export const skillWriteTool = {
         nameCheck.reason === "reserved" ? "reserved_name" : "invalid_name";
       const message =
         nameCheck.reason === "reserved"
-          ? `'${input.name}' is reserved by a built-in slash command (help, skills, clear, exit).`
+          ? `'${input.name}' is reserved by a built-in slash command (help, skills, dream, clear, exit).`
           : nameCheck.reason === "too_long"
             ? `Skill name too long (max 64 chars after normalization).`
             : `'${input.name}' is not a valid skill name. After normalization (lowercase, [a-z0-9-], trimmed hyphens) it is empty.`;

package/src/tools/thread/search.ts

@@ -1,11 +1,8 @@
 import { z } from "zod";
 import {
-  getThread,
-  type Interaction,
   type InteractionKind,
   type InteractionRole,
-  listThreads,
-  type Thread,
+  searchThreads,
 } from "../../threads/store.ts";
 import type { ToolDefinition } from "../tool.ts";
 
@@ -19,8 +16,6 @@ const KINDS = [
   "status_change",
 ] as const;
 
-const SNIPPET_MAX = 240;
-
 const inputSchema = z.object({
   pattern: z
     .string()
@@ -112,17 +107,16 @@ export const searchThreadsTool = {
       };
     }
 
-    const sinceMs = input.since
-      ? Date.parse(input.since)
-      : Number.NEGATIVE_INFINITY;
-    const untilMs = input.until
-      ? Date.parse(input.until)
-      : Number.POSITIVE_INFINITY;
-
-    let threads: Thread[];
+    let scanResult: Awaited<ReturnType<typeof searchThreads>>;
     try {
-      threads = await listThreads(ctx.projectDir, {
+      scanResult = await searchThreads(ctx.projectDir, {
+        regex,
+        role: input.role,
+        kind: input.kind,
         type: input.thread_type,
+        since: input.since ? new Date(input.since) : undefined,
+        until: input.until ? new Date(input.until) : undefined,
+        maxResults: input.max_results,
       });
     } catch (err) {
       return {
@@ -134,75 +128,29 @@ export const searchThreadsTool = {
       };
     }
 
-    type Hit = z.infer<typeof HitSchema>;
-    const matches: Hit[] = [];
-    let scanned = 0;
-
-    for (const t of threads) {
-      const startedMs = t.started_at.getTime();
-      if (startedMs < sinceMs || startedMs > untilMs) continue;
-      const data = await getThread(ctx.projectDir, t.id);
-      if (!data) continue;
-      scanned++;
-      for (const ix of data.interactions) {
-        if (input.role && ix.role !== input.role) continue;
-        if (input.kind && ix.kind !== input.kind) continue;
-        if (!matchInteraction(ix, regex)) continue;
-        matches.push({
-          thread_id: t.id,
-          thread_title: t.title || "(untitled)",
-          thread_type: t.type,
-          sequence: ix.sequence,
-          role: ix.role,
-          kind: ix.kind,
-          content_snippet: snippetForMatch(ix.content, regex),
-          created_at: ix.created_at.toISOString(),
-        });
-        if (matches.length >= input.max_results) break;
-      }
-      if (matches.length >= input.max_results) break;
-    }
+    const matches = scanResult.hits.map((h) => ({
+      thread_id: h.thread_id,
+      thread_title: h.thread_title,
+      thread_type: h.thread_type,
+      sequence: h.sequence,
+      role: h.role,
+      kind: h.kind,
+      content_snippet: h.content_snippet,
+      created_at: h.created_at.toISOString(),
+    }));
 
     return {
       matches,
-      threads_scanned: scanned,
+      threads_scanned: scanResult.threadsScanned,
       is_error: false,
       next_action_hint:
         matches.length === 0
-          ? `No hits in ${scanned} thread(s). Try a broader pattern or remove role/kind filters.`
+          ? `No hits in ${scanResult.threadsScanned} thread(s). Try a broader pattern or remove role/kind filters.`
           : `Pass any (thread_id, sequence) into view_thread({ id: thread_id, offset: sequence - 1, limit: 5 }) to read surrounding context.`,
     };
   },
 } satisfies ToolDefinition<typeof inputSchema, typeof outputSchema>;
 
-function matchInteraction(ix: Interaction, regex: RegExp): boolean {
-  // We treat the user-visible content as the primary haystack, but a
-  // tool_use interaction's content is just "Calling <name>" — fall through
-  // to the tool name + JSON args so a search for an exact tool argument
-  // still finds the call.
-  if (regex.test(ix.content)) return true;
-  if (ix.tool_name && regex.test(ix.tool_name)) return true;
-  if (ix.tool_input && regex.test(ix.tool_input)) return true;
-  return false;
-}
-
-/**
- * Pick a short window around the first regex match so the agent gets enough
- * context to know whether the hit is relevant without paging the whole
- * interaction. Falls back to the head when the match index isn't available.
- */
-function snippetForMatch(content: string, regex: RegExp): string {
-  const m = regex.exec(content);
-  if (!m) return content.slice(0, SNIPPET_MAX);
-  const idx = m.index;
-  const start = Math.max(0, idx - 60);
-  const end = Math.min(content.length, idx + SNIPPET_MAX - 60);
-  let snippet = content.slice(start, end);
-  if (start > 0) snippet = `…${snippet}`;
-  if (end < content.length) snippet = `${snippet}…`;
-  return snippet;
-}
-
 // Keep the role/kind unions exported for tests that want to type-pin filters.
 export type SearchThreadsRole = InteractionRole;
 export type SearchThreadsKind = InteractionKind;

package/src/workers/store.ts

@@ -87,7 +87,7 @@ export async function registerWorker(
  */
 export async function heartbeat(projectDir: string, id: string): Promise<void> {
   const worker = await readWorker(projectDir, id);
-  if (!worker || worker.status !== "running") return;
+  if (worker?.status !== "running") return;
   worker.last_heartbeat_at = new Date().toISOString();
   await writeWorker(projectDir, worker);
 }
@@ -97,7 +97,7 @@ export async function markWorkerStopped(
   id: string,
 ): Promise<void> {
   const worker = await readWorker(projectDir, id);
-  if (!worker || worker.status !== "running") return;
+  if (worker?.status !== "running") return;
   worker.status = "stopped";
   worker.stopped_at = new Date().toISOString();
   await writeWorker(projectDir, worker);
@@ -130,7 +130,7 @@ export async function reapDeadWorkers(
   const reaped: string[] = [];
   for (const id of ids) {
     const w = await readWorker(projectDir, id);
-    if (!w || w.status !== "running") continue;
+    if (w?.status !== "running") continue;
     const heartbeatMs = Date.parse(w.last_heartbeat_at);
     if (Number.isFinite(heartbeatMs) && heartbeatMs >= cutoff) continue;
     w.status = "dead";
@@ -162,7 +162,7 @@ export async function pruneStoppedWorkers(
   const pruned: string[] = [];
   for (const id of ids) {
     const w = await readWorker(projectDir, id);
-    if (!w || w.status !== "stopped" || !w.stopped_at) continue;
+    if (w?.status !== "stopped" || !w.stopped_at) continue;
     const stoppedMs = Date.parse(w.stopped_at);
     if (Number.isFinite(stoppedMs) && stoppedMs >= cutoff) continue;
     try {