thursday-agent 0.5.0 → 0.6.0

package/features/bot/bot.action.ts

@@ -7,20 +7,20 @@ import { publicError } from "@/lib/public-error";
 import {
   createBot,
   deleteBot,
-  findBot,
+  findJobBot,
   updateBot,
   writeBotMemoryOn,
 } from "./bot.query";
 import {
-  answerTask,
-  cancelTask,
-  removeFinishedTasks,
-  removeTask,
-  startTask,
+  answerThread,
+  cancelThread,
+  removeFinishedThreads,
+  removeThread,
+  startThread,
 } from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
-import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { markSeen, resolveTask } from "./task.query";
+import { findBotSeed, rollSeedIcons } from "./bot.seed";
+import { markSeen, resolveThread } from "./thread.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -41,8 +41,8 @@ const SeedPickSchema = z.object({
   name: z.string().trim().min(1).max(80),
   provider: textModelProviderSchema.nullish(),
   model: z.string().trim().min(1).max(80).nullish(),
-  /** The colour the intro already showed for this bot. Rolled here when the caller had no screen. */
-  color: botIconSchema.shape.color,
+  /** The face the intro already showed for this bot. Rolled here when the caller had no screen. */
+  icon: botIconSchema.optional(),
 });
 
 /**
@@ -53,9 +53,9 @@ const SeedPickSchema = z.object({
 export const createSeedBotsAction = serverAction(async (picks: unknown) => {
   const wanted = SeedPickSchema.array().max(20).parse(picks);
 
-  // Seeds carry no colour of their own (bot.seed); one roll covers the whole
-  // batch so bots made together never come out the same colour
-  const rolled = rollSeedColors();
+  // Seeds carry no face of their own (bot.seed); one roll covers the whole batch
+  // so bots made together never come out looking alike
+  const rolled = rollSeedIcons();
 
   const created: string[] = [];
   for (const [at, pick] of wanted.entries()) {
@@ -65,7 +65,7 @@ export const createSeedBotsAction = serverAction(async (picks: unknown) => {
       name: seed.name,
       description: seed.description,
       systemPrompt: seed.systemPrompt,
-      icon: { ...seed.icon, color: pick.color ?? rolled[at % rolled.length] },
+      icon: pick.icon ?? rolled[at % rolled.length],
       provider: pick.provider,
       model: pick.model,
       toolIds: [],
@@ -84,9 +84,9 @@ export const setBotMemoryOnAction = serverAction(async (on: unknown) => {
   await writeBotMemoryOn(on === true);
 });
 
-// Tasks are opened by the `delegate` tool during a call, or here when the user
+// Threads are opened by the `delegate` tool during a call, or here when the user
 // hands one over from the screen. Each returns at once, the run itself continues
-// in bot.runner behind `after()`.
+// as promises held by bot.runner.
 
 /** Words a label keeps; the rest of the message is the request, which the bot reads in full. */
 const LABEL_WORDS = 4;
@@ -103,14 +103,16 @@ function labelFor(request: string): string {
  * is the whole request — there is no conversation to draw the rest from, which is
  * why the box asks for a sentence rather than a word.
  */
-export const startTaskAction = serverAction(
+export const startThreadAction = serverAction(
   async (bot: string, request: string) => {
     const said = request.trim();
     if (!said) publicError("Nothing to hand over.");
-    const worker = await findBot(bot);
-    if (!worker) publicError(`No bot called "${bot}".`);
+    // Resolved as a delegated job is, so an install with no bots still has its worker
+    const worker = await findJobBot(bot);
+    if (!worker || worker.disabled)
+      publicError(`No enabled bot called "${bot}".`);
     const label = labelFor(said);
-    const id = await startTask({
+    const id = await startThread({
       bot: worker.name,
       request: said,
       label,
@@ -120,33 +122,38 @@ export const startTaskAction = serverAction(
   },
 );
 
-export const answerTaskAction = serverAction(
-  async (ref: string, answer: string) => {
-    const task = await resolveTask(ref);
-    if (!task) publicError(`No job called "${ref}".`);
+export const answerThreadAction = serverAction(
+  async (ref: string, answer: string, recipient?: string, replyTo?: string) => {
+    const thread = await resolveThread(ref);
+    if (!thread) publicError(`No job called "${ref}".`);
     if (!answer.trim()) publicError("Nothing to tell it.");
-    await answerTask(task.id, answer.trim());
-    return { id: task.id, label: task.label, status: "running" as const };
+    await answerThread(thread.id, answer.trim(), "user", recipient, replyTo);
+    return { id: thread.id, label: thread.label, status: "running" as const };
   },
 );
 
-export const cancelTaskAction = serverAction(async (ref: string) => {
-  const task = await resolveTask(ref);
-  if (!task) publicError(`No job called "${ref}".`);
-  await cancelTask(task.id);
-  return { id: task.id, label: task.label, status: "cancelled" as const };
+export const cancelThreadAction = serverAction(async (ref: string) => {
+  const thread = await resolveThread(ref);
+  if (!thread) publicError(`No job called "${ref}".`);
+  await cancelThread(thread.id);
+  return { id: thread.id, label: thread.label, status: "cancelled" as const };
 });
 
-/** Marks endings as had by the user: relayed on a call, or on a task list they opened. Batched, since both reach many at once. */
+/** Marks threads as read by the user: opened on screen. Their relays are settled with them (thread.query markSeen). */
 export const markSeenAction = serverAction(async (ids: string[]) => {
   await markSeen(ids.filter((id) => typeof id === "string" && id));
 });
 
-export const deleteTaskAction = serverAction(async (id: string) => {
-  if (!(await removeTask(id))) publicError("Task not found");
+export const deleteThreadAction = serverAction(async (id: string) => {
+  if (!(await removeThread(id))) publicError("Thread not found");
 });
 
 /** Empties the log of what is over. Running and waiting jobs are not touched. */
-export const clearFinishedTasksAction = serverAction(async () => {
-  return { removed: await removeFinishedTasks() };
+export const clearFinishedThreadsAction = serverAction(async () => {
+  return { removed: await removeFinishedThreads() };
+});
+
+export const acceptThreadRelaysAction = serverAction(async (ids: unknown) => {
+  const { acceptRoomRelays } = await import("./room.query");
+  await acceptRoomRelays(z.number().int().positive().array().parse(ids));
 });

package/features/bot/bot.memory.ts

@@ -1,6 +1,15 @@
-import { open, readdir, stat } from "node:fs/promises";
+import type { Stats } from "node:fs";
+import {
+  open,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  utimes,
+  writeFile,
+} from "node:fs/promises";
 import { join } from "node:path";
-import { BOT_MEMORY_LISTED } from "@/config";
+import { BOT_MEMORY_LIMITS } from "@/config";
 import { botFolder, WORKSPACE } from "@/features/workspace/workspace";
 import type { BotMemory, BotMemoryFile } from "./bot.schema";
 
@@ -19,42 +28,150 @@ const HEAD_BYTES = 1024;
 
 /**
  * Newest first. `limit` is how many are read for their first line: the prompt lists
- * BOT_MEMORY_LISTED, the bot's page (Settings > Bots) as many as a Workspace folder shows.
+ * BOT_MEMORY_LIMITS.files, the bot's page (Settings > Bots) as many as a Workspace folder shows.
  */
 export async function listBotMemory(
   bot: string,
-  limit = BOT_MEMORY_LISTED,
+  limit = BOT_MEMORY_LIMITS.files,
 ): Promise<BotMemory> {
   const folder = botMemoryFolder(bot);
   const dir = join(WORKSPACE, folder);
-  const names = await readdir(dir).catch(() => []);
-  const found = await Promise.all(
-    names
-      .filter((name) => !name.startsWith("."))
-      .map(async (name) => {
-        const info = await stat(join(dir, name)).catch(() => null);
-        return info?.isFile()
-          ? { name, changed: info.mtimeMs, bytes: info.size }
-          : null;
-      }),
+  const files = (await readMemoryFolder(dir)).sort(
+    (a, b) => b.info.mtimeMs - a.info.mtimeMs,
   );
-  const files = found
-    .filter((file) => file !== null)
-    .sort((a, b) => b.changed - a.changed);
   const entries = await Promise.all(
     files.slice(0, limit).map(
-      async ({ name, changed, bytes }): Promise<BotMemoryFile> => ({
+      async ({ name, info }): Promise<BotMemoryFile> => ({
         file: name,
         path: `${folder}/${name}`,
         line: await firstLine(join(dir, name)),
-        at: new Date(changed),
-        bytes,
+        at: new Date(info.mtimeMs),
+        bytes: info.size,
       }),
     ),
   );
   return { folder, entries, total: files.length };
 }
 
+/** What counts as a memory file, for the listing and the limits alike: a plain file, not hidden. */
+async function readMemoryFolder(
+  dir: string,
+): Promise<{ name: string; info: Stats }[]> {
+  const names = await readdir(dir).catch(() => []);
+  const found = await Promise.all(
+    names
+      .filter((name) => !name.startsWith("."))
+      .map(async (name) => {
+        const info = await stat(join(dir, name)).catch(() => null);
+        return info?.isFile() ? { name, info } : null;
+      }),
+  );
+  return found.filter((file) => file !== null);
+}
+
+/**
+ * A bot's memory as it stood before a command, so what the command takes past
+ * BOT_MEMORY_LIMITS can be put back. A file already past the limit is held without its
+ * text: there is nothing within the limit to put back.
+ */
+export type HeldBotMemory = Map<
+  string,
+  {
+    text: string | null;
+    size: number;
+    mtimeMs: number;
+    atime: Date;
+    mtime: Date;
+  }
+>;
+
+export async function holdBotMemory(bot: string): Promise<HeldBotMemory> {
+  const dir = join(WORKSPACE, botMemoryFolder(bot));
+  const held: HeldBotMemory = new Map();
+  await Promise.all(
+    (await readMemoryFolder(dir)).map(async ({ name, info }) => {
+      // More than four bytes a character is past the limit without reading it
+      const text =
+        info.size > BOT_MEMORY_LIMITS.chars * 4
+          ? null
+          : await readFile(join(dir, name), "utf8").catch(() => null);
+      held.set(name, {
+        text:
+          text !== null && charCount(text) <= BOT_MEMORY_LIMITS.chars
+            ? text
+            : null,
+        size: info.size,
+        mtimeMs: info.mtimeMs,
+        atime: info.atime,
+        mtime: info.mtime,
+      });
+    }),
+  );
+  return held;
+}
+
+/**
+ * Puts back what was done to a bot's memory past BOT_MEMORY_LIMITS since `held`, and says
+ * so in lines the bot can act on; null when nothing went past. A file written past `chars`
+ * goes back to what it was, or is removed when it is new; new files that take the folder
+ * past `files` are removed. A file that was already past the limit stays and is named.
+ */
+export async function keepBotMemory(
+  bot: string,
+  held: HeldBotMemory,
+): Promise<string | null> {
+  const folder = botMemoryFolder(bot);
+  const dir = join(WORKSPACE, folder);
+  const { files: most, chars } = BOT_MEMORY_LIMITS;
+  const lines: string[] = [];
+  const fresh: string[] = [];
+  let count = 0;
+
+  for (const { name, info } of await readMemoryFolder(dir)) {
+    count += 1;
+    const was = held.get(name);
+    if (was && was.size === info.size && was.mtimeMs === info.mtimeMs) {
+      continue;
+    }
+    const path = join(dir, name);
+    const length = charCount(await readFile(path, "utf8").catch(() => ""));
+    if (length <= chars) {
+      if (!was) fresh.push(name);
+      continue;
+    }
+    const size = `${length.toLocaleString("en-US")} characters, past the ${chars.toLocaleString("en-US")} a memory file holds`;
+    if (!was) {
+      await rm(path, { force: true });
+      count -= 1;
+      lines.push(
+        `Not kept: \`${folder}/${name}\` came to ${size}, so it was removed. Write it again shorter.`,
+      );
+    } else if (was.text !== null) {
+      await writeFile(path, was.text);
+      await utimes(path, was.atime, was.mtime);
+      lines.push(
+        `Not kept: \`${folder}/${name}\` came to ${size}, so it is back as it was. Write it again shorter.`,
+      );
+    } else {
+      lines.push(`\`${folder}/${name}\` is ${size}. Shorten it.`);
+    }
+  }
+
+  if (count > most && fresh.length) {
+    await Promise.all(
+      fresh.map((name) => rm(join(dir, name), { force: true })),
+    );
+    const named = fresh.map((name) => `\`${folder}/${name}\``).join(", ");
+    lines.push(
+      `Not kept: your memory holds ${most} files at most and this made ${count}, so ${named} ${fresh.length === 1 ? "was" : "were"} removed. Delete or merge files no longer worth keeping, then write it again.`,
+    );
+  }
+  return lines.length ? lines.join("\n") : null;
+}
+
+/** A file's length as BOT_MEMORY_LIMITS counts it. */
+const charCount = (text: string): number => [...text.trim()].length;
+
 /**
  * The line a file is listed by: its first, without a heading's `#`. A file that opens with
  * frontmatter anyway — a shape models are trained on — is listed by its `description`, or by

package/features/bot/bot.query.ts

@@ -4,10 +4,11 @@ import {
   botMcpToolTable,
   botTable,
   mcpToolTable,
-  taskTable,
+  threadTable,
 } from "@/database/tables";
 import type { TextModelProviderId } from "@/features/ai/model.schema";
 import { readConfig, writeConfig } from "@/features/config/config.query";
+import { botFolderName } from "@/features/workspace/workspace";
 import {
   BOT_MEMORY_KEY,
   type BotForm,
@@ -98,17 +99,17 @@ export async function findAllBots() {
       })
       .from(botMcpToolTable)
       .innerJoin(mcpToolTable, eq(botMcpToolTable.toolId, mcpToolTable.id)),
-    // Grouped by name; tasks point at bots by name (tables.ts task.bot)
+    // Grouped by name; threads point at bots by name (tables.ts thread.bot)
     database
       .select({
-        bot: taskTable.bot,
-        input: sql<number>`coalesce(sum(${taskTable.inputTokens}), 0)`,
-        output: sql<number>`coalesce(sum(${taskTable.outputTokens}), 0)`,
+        bot: threadTable.bot,
+        input: sql<number>`coalesce(sum(${threadTable.inputTokens}), 0)`,
+        output: sql<number>`coalesce(sum(${threadTable.outputTokens}), 0)`,
         // Raw max over a timestamp column arrives as integer seconds
-        lastJobAt: sql<number | null>`max(${taskTable.updatedAt})`,
+        lastJobAt: sql<number | null>`max(${threadTable.updatedAt})`,
       })
-      .from(taskTable)
-      .groupBy(taskTable.bot),
+      .from(threadTable)
+      .groupBy(threadTable.bot),
   ]);
 
   const byBot = new Map<string, PinnedTool[]>();
@@ -155,9 +156,25 @@ export async function findBot(name: string) {
   return bot ?? null;
 }
 
-/** Returns null when the name is taken: two bots with one name would be a coin toss at delegate time. */
+/**
+ * Every name that has folders in the workspace: the rows, switched off or not,
+ * and DEFAULT_BOT, which works without one.
+ */
+export async function listBotNames(): Promise<string[]> {
+  const rows = await database.select({ name: botTable.name }).from(botTable);
+  return [...new Set([...rows.map((row) => row.name), DEFAULT_BOT.name])];
+}
+
+/**
+ * Returns null when the name is taken: two bots with one name would be a coin
+ * toss at delegate time, and two whose names give one folder would share their
+ * memory and artifacts (workspace.ts botFolderName).
+ */
 export async function createBot(form: BotForm) {
-  if (await findBot(form.name)) return null;
+  const folder = botFolderName(form.name).toLowerCase();
+  const rows = await database.select({ name: botTable.name }).from(botTable);
+  if (rows.some((row) => botFolderName(row.name).toLowerCase() === folder))
+    return null;
 
   const { toolIds, ...values } = pickedModel(form);
   const [bot] = await database.insert(botTable).values(values).returning();
@@ -170,7 +187,7 @@ export async function updateBot(name: string, patch: Partial<BotForm>) {
   // (pickedModel reads a missing field as null and would clear the other)
   const { toolIds, ...values } =
     "provider" in patch || "model" in patch ? pickedModel(patch) : patch;
-  // Renaming would orphan pinned tools and every task sent to the old name, so name is never patched
+  // Renaming would orphan pinned tools and every thread sent to the old name, so name is never patched
   delete (values as { name?: string }).name;
 
   const [bot] = Object.keys(values).length