thursday-agent 0.2.0 → 0.4.0

package/features/ai/tools/workspace.tool.ts

@@ -1,9 +1,10 @@
 import { relative } from "node:path";
 import { type ToolSet, tool } from "ai";
 import z from "zod";
+import { EXEC_TIMEOUT_MS } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { writeRefusal } from "@/features/workspace/workspace";
-import { EXEC_TIMEOUT_MS, type Sandbox } from "@/lib/sandbox";
+import type { Sandbox } from "@/lib/sandbox";
 
 /**
  * Shell access, plus `write_file` for bots: multi-line files through a
@@ -17,6 +18,8 @@ export const createWorkspaceTools = (
     env?: Record<string, string>;
     /** Attach the shell guide to this run's first `bash` result (bots only). */
     guide?: boolean;
+    /** How long one command may run; unset is the sandbox's own limit (config EXEC_TIMEOUT_MS). */
+    timeoutMs?: number;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -44,6 +47,7 @@ export const createWorkspaceTools = (
       const result = await sandbox.exec(command, {
         signal: abortSignal,
         env: options.env,
+        timeoutMs: options.timeoutMs,
       });
       if (!owed) return result;
       owed = false;

package/features/bot/bot.action.ts

@@ -5,12 +5,11 @@ import { textModelProviderSchema } from "@/features/ai/model.schema";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
 import {
-  clearBotNote,
   createBot,
   deleteBot,
   findBot,
   updateBot,
-  writeBotNotesOn,
+  writeBotMemoryOn,
 } from "./bot.query";
 import {
   answerTask,
@@ -21,7 +20,7 @@ import {
 } from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
 import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { markReported, resolveTask } from "./task.query";
+import { markSeen, resolveTask } from "./task.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -80,18 +79,9 @@ export const deleteBotAction = serverAction(async (name: string) => {
   if (!(await deleteBot(name))) publicError("Bot not found");
 });
 
-/**
- * Throws away what a bot wrote about itself. The only human touch on notes:
- * they are never edited here, because a line the user typed would come back
- * rewritten by the bot's next report.
- */
-export const clearBotNoteAction = serverAction(async (name: string) => {
-  await clearBotNote(name);
-});
-
-/** Switched off, no bot writes to its own instructions and none is shown one. What is already written stays. */
-export const setBotNotesOnAction = serverAction(async (on: unknown) => {
-  await writeBotNotesOn(on === true);
+/** Switched off, no bot is shown its own memory. What is already written stays on disk. */
+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
@@ -120,7 +110,12 @@ export const startTaskAction = serverAction(
     const worker = await findBot(bot);
     if (!worker) publicError(`No bot called "${bot}".`);
     const label = labelFor(said);
-    const id = await startTask({ bot: worker.name, request: said, label });
+    const id = await startTask({
+      bot: worker.name,
+      request: said,
+      label,
+      from: "user",
+    });
     return { id, label, bot: worker.name };
   },
 );
@@ -142,9 +137,9 @@ export const cancelTaskAction = serverAction(async (ref: string) => {
   return { id: task.id, label: task.label, status: "cancelled" as const };
 });
 
-/** Marks tasks as relayed to the call, clearing their inbox dot. Batched because a call opening relays everything pending at once. */
-export const markReportedAction = serverAction(async (ids: string[]) => {
-  await markReported(ids.filter((id) => typeof id === "string" && id));
+/** 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. */
+export const markSeenAction = serverAction(async (ids: string[]) => {
+  await markSeen(ids.filter((id) => typeof id === "string" && id));
 });
 
 export const deleteTaskAction = serverAction(async (id: string) => {

package/features/bot/bot.memory.ts

@@ -0,0 +1,89 @@
+import { open, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { BOT_MEMORY_LISTED } from "@/config";
+import { botFolder, WORKSPACE } from "@/features/workspace/workspace";
+import type { BotMemory, BotMemoryFile } from "./bot.schema";
+
+/**
+ * A bot's own memory: files it keeps in its folder, one topic each, written and read with
+ * its own shell. The disk is the only index — a file's first line is its listing line — so
+ * keeping something is one write, and no list can fall out of step with the files.
+ */
+
+/** Workspace-relative, the way a prompt names it (config PATHS.bots). */
+export const botMemoryFolder = (bot: string): string =>
+  `${botFolder(bot)}/memory`;
+
+/** Enough of a file to find its first line in; the rest is the bot's to open. */
+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.
+ */
+export async function listBotMemory(
+  bot: string,
+  limit = BOT_MEMORY_LISTED,
+): 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 = 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> => ({
+        file: name,
+        path: `${folder}/${name}`,
+        line: await firstLine(join(dir, name)),
+        at: new Date(changed),
+        bytes,
+      }),
+    ),
+  );
+  return { folder, entries, total: files.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
+ * the first line after it.
+ */
+async function firstLine(path: string): Promise<string> {
+  const handle = await open(path, "r").catch(() => null);
+  if (!handle) return "";
+  try {
+    const head = Buffer.alloc(HEAD_BYTES);
+    const { bytesRead } = await handle.read(head, 0, HEAD_BYTES, 0);
+    const lines = head
+      .toString("utf8", 0, bytesRead)
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+    if (lines[0] === "---") {
+      const said = lines.find((line) => line.startsWith("description:"));
+      if (said) {
+        return said
+          .slice("description:".length)
+          .trim()
+          .replace(/^["']|["']$/g, "");
+      }
+      const end = lines.indexOf("---", 1);
+      return end > 0 ? (lines[end + 1] ?? "").replace(/^#+\s*/, "") : "";
+    }
+    return (lines[0] ?? "").replace(/^#+\s*/, "");
+  } finally {
+    await handle.close();
+  }
+}

package/features/bot/bot.query.ts

@@ -1,9 +1,7 @@
 import { eq, inArray, sql } from "drizzle-orm";
-import { BOT_NOTES } from "@/config";
 import { database } from "@/database/db";
 import {
   botMcpToolTable,
-  botNoteTable,
   botTable,
   mcpToolTable,
   taskTable,
@@ -11,11 +9,11 @@ import {
 import type { TextModelProviderId } from "@/features/ai/model.schema";
 import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
-  BOT_NOTES_KEY,
+  BOT_MEMORY_KEY,
   type BotForm,
   type BotIcon,
   DEFAULT_BOT,
-  isBotNotesOn,
+  isBotMemoryOn,
   type JobBot,
   type PinnedTool,
   pickedModel,
@@ -31,6 +29,8 @@ const asJobBot = (row: {
   /** Empty runs on the app default model (bot.run resolveModel). */
   provider: TextModelProviderId | null;
   model: string | null;
+  disabled: boolean;
+  compactAt: number | null;
 }): JobBot => ({
   name: row.name,
   description: row.description,
@@ -38,21 +38,36 @@ const asJobBot = (row: {
   icon: row.icon,
   provider: row.provider,
   model: row.model,
+  disabled: row.disabled,
+  compactAt: row.compactAt,
 });
 
-/** Who a job can go to: the user's bots, or DEFAULT_BOT when there are none. */
+/**
+ * Who a job can go to: the user's bots, or DEFAULT_BOT when there are none.
+ * Switched-off bots are left out here and nowhere else — this one read is what
+ * every prompt's roster and `delegate`'s list are built from, so off is off in
+ * all of them without a second rule to keep.
+ */
 export async function listJobBots(): Promise<JobBot[]> {
   const rows = await database
     .select()
     .from(botTable)
     .orderBy(botTable.createdAt);
 
-  return rows.length ? rows.map(asJobBot) : [DEFAULT_BOT];
+  // The fallback answers "no bots exist", never "every bot is off": switching
+  // them all off is a choice, and conjuring a worker would undo it.
+  return rows.length
+    ? rows.filter((row) => !row.disabled).map(asJobBot)
+    : [DEFAULT_BOT];
 }
 
 /**
- * The bot a job names. Exact name first, then case-insensitive only; no looser
- * matching. A miss returns null so `delegate` can list the roster instead.
+ * The bot a job names, switched off or not: a job already under way resumes
+ * through here, and refusing it would strand a thread the user can still answer.
+ * `delegate` is what checks `disabled`, because that is where a bot is picked.
+ *
+ * Exact name first, then case-insensitive only; no looser matching. A miss
+ * returns null so `delegate` can list the roster instead.
  */
 export async function findJobBot(name: string): Promise<JobBot | null> {
   const row = await findBot(name);
@@ -60,13 +75,19 @@ export async function findJobBot(name: string): Promise<JobBot | null> {
 
   // Case is not a different name: the spoken name arrives through a transcript
   const said = name.trim().toLowerCase();
-  const bots = await listJobBots();
-  return bots.find((bot) => bot.name.toLowerCase() === said) ?? null;
+  const [match] = await database
+    .select()
+    .from(botTable)
+    .where(eq(sql`lower(${botTable.name})`, said));
+  if (match) return asJobBot(match);
+
+  // The worker that exists when no row does; it has no row to match against
+  return DEFAULT_BOT.name.toLowerCase() === said ? DEFAULT_BOT : null;
 }
 
 /** Bots with their pinned tools and token totals: a set of queries plus grouping, not a join. */
 export async function findAllBots() {
-  const [bots, pins, spent, notes] = await Promise.all([
+  const [bots, pins, spent] = await Promise.all([
     database.select().from(botTable).orderBy(botTable.createdAt),
     database
       .select({
@@ -88,7 +109,6 @@ export async function findAllBots() {
       })
       .from(taskTable)
       .groupBy(taskTable.bot),
-    database.select().from(botNoteTable),
   ]);
 
   const byBot = new Map<string, PinnedTool[]>();
@@ -110,59 +130,21 @@ export async function findAllBots() {
         : [[row.bot, new Date(Number(row.lastJobAt) * 1000)] as const],
     ),
   );
-  const noteOf = new Map(notes.map((row) => [row.bot, row]));
   return bots.map((bot) => ({
     ...bot,
     tools: byBot.get(bot.name) ?? [],
     tokens: tokensOf.get(bot.name) ?? { input: 0, output: 0 },
     lastJobAt: lastJobOf.get(bot.name) ?? null,
-    note: noteOf.get(bot.name)?.text ?? null,
-    noteAt: noteOf.get(bot.name)?.updatedAt ?? null,
   }));
 }
 
-// A bot's own notes. Nothing here belongs to a job: the row survives every job
-// the bot runs and is read back into its next prompt (ai/prompts/bot.prompt).
-
-/** What this bot has written to itself. Keyed by name, so DEFAULT_BOT has one too. */
-export async function readBotNote(bot: string): Promise<string | null> {
-  const [row] = await database
-    .select({ text: botNoteTable.text })
-    .from(botNoteTable)
-    .where(eq(botNoteTable.bot, bot));
-  return row?.text ?? null;
-}
-
-/**
- * The whole block, as the pass rewrote it (bot.notes). Cut rather than refused: the schema
- * already caps it, and a run that gets this far has handed its report back. Empty clears it.
- */
-export async function writeBotNote(bot: string, text: string): Promise<void> {
-  const next = text.trim().slice(0, BOT_NOTES.chars).trim();
-  if (!next) return clearBotNote(bot);
-
-  const updatedAt = new Date();
-  await database
-    .insert(botNoteTable)
-    .values({ bot, text: next, updatedAt })
-    .onConflictDoUpdate({
-      target: botNoteTable.bot,
-      set: { text: next, updatedAt },
-    });
-}
-
-/** Whether any bot keeps its own instructions at all (bot.schema BOT_NOTES_KEY). */
-export async function readBotNotesOn(): Promise<boolean> {
-  return isBotNotesOn(await readConfig(BOT_NOTES_KEY));
-}
-
-export async function writeBotNotesOn(on: boolean): Promise<void> {
-  await writeConfig(BOT_NOTES_KEY, on ? "on" : "off");
+/** Whether bots keep their own memory at all (bot.schema BOT_MEMORY_KEY). */
+export async function readBotMemoryOn(): Promise<boolean> {
+  return isBotMemoryOn(await readConfig(BOT_MEMORY_KEY));
 }
 
-/** The one thing the user does to notes: throw them away when a bot has learned something wrong. */
-export async function clearBotNote(bot: string): Promise<void> {
-  await database.delete(botNoteTable).where(eq(botNoteTable.bot, bot));
+export async function writeBotMemoryOn(on: boolean): Promise<void> {
+  await writeConfig(BOT_MEMORY_KEY, on ? "on" : "off");
 }
 
 export async function findBot(name: string) {
@@ -228,7 +210,5 @@ export async function deleteBot(name: string) {
     .delete(botTable)
     .where(eq(botTable.name, name))
     .returning({ name: botTable.name });
-  // Notes are keyed by name with no foreign key, so nothing cascades for them.
-  await clearBotNote(name);
   return removed.length > 0;
 }