thursday-agent 0.4.0 → 0.6.0

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

@@ -8,7 +8,6 @@ import {
 } from "ai";
 import { format } from "date-fns";
 import z from "zod";
-import { PATHS } from "@/config";
 import {
   buildImageModel,
   buildSpeechModel,
@@ -25,9 +24,20 @@ import { errorToString } from "@/lib/utils";
  * Media tools (image, speech, transcription, video), exposed behind `tool_search`/`tool_call`
  * under one server name (config STUDIO_SERVER) like an MCP server's tools. They are code rather
  * than skills or shell commands because each needs a key, and keys never reach a bot's shell.
- * Bytes go to a file under `artifacts/`; only the path travels, since tool results are replayed on every resume.
+ * Bytes go to a file in the calling bot's artifacts folder; only the path travels, since tool results are replayed on every resume.
  */
 
+/**
+ * What a run hands a studio tool: the shell's sandbox, and `artifacts`, the
+ * calling bot's folder, which is where what it makes is finished work the user
+ * opens (workspace.ts botArtifacts).
+ */
+type StudioContext = {
+  sandbox: Sandbox;
+  artifacts: string;
+  abortSignal?: AbortSignal;
+};
+
 /** One studio tool as `tool_search` describes it and `tool_call` runs it. The zod schema becomes JSON Schema for the model (connected.ts). */
 export type StudioTool = {
   name: string;
@@ -35,7 +45,7 @@ export type StudioTool = {
   inputSchema: z.ZodObject<z.ZodRawShape>;
   execute: (
     args: Record<string, unknown>,
-    ctx: { sandbox: Sandbox; abortSignal?: AbortSignal },
+    ctx: StudioContext,
   ) => Promise<string>;
 };
 
@@ -46,7 +56,7 @@ function define<Shape extends z.ZodRawShape>(spec: {
   inputSchema: z.ZodObject<Shape>;
   execute: (
     args: z.infer<z.ZodObject<Shape>>,
-    ctx: { sandbox: Sandbox; abortSignal?: AbortSignal },
+    ctx: StudioContext,
   ) => Promise<string>;
 }): StudioTool {
   return {
@@ -59,14 +69,6 @@ function define<Shape extends z.ZodRawShape>(spec: {
   };
 }
 
-/** Under artifacts: what is made here is finished work the user opens. */
-const DIR = {
-  images: `${PATHS.artifacts}/images`,
-  audio: `${PATHS.artifacts}/audio`,
-  transcripts: `${PATHS.artifacts}/transcripts`,
-  videos: `${PATHS.artifacts}/videos`,
-};
-
 /** A filename someone can recognise a week later, out of what was asked for. */
 function fileName(stem: string, ext: string): string {
   const slug = stem
@@ -92,7 +94,7 @@ async function save(
 
 /** The path first, on its own line: whoever draws this row reads line one as the file to open. */
 const saved = (path: string) =>
-  `${path}\nSaved. Give the user this path — the file opens from the task row. Do not describe it back to them; they can open it.`;
+  `${path}\nSaved. Give the user this path — the file opens from the thread row. Do not describe it back to them; they can open it.`;
 
 /** `video/mp4` → `mp4`, with a fallback for a provider that says nothing. */
 const extOf = (mediaType: string | undefined, fallback: string) =>
@@ -121,7 +123,10 @@ const imageTool = async (): Promise<StudioTool | null> => {
         .nullish()
         .describe("Aspect ratio. Null for square."),
     }),
-    execute: async ({ prompt, aspectRatio }, { sandbox, abortSignal }) => {
+    execute: async (
+      { prompt, aspectRatio },
+      { sandbox, artifacts, abortSignal },
+    ) => {
       const { image } = await generateImage({
         model,
         prompt,
@@ -130,7 +135,7 @@ const imageTool = async (): Promise<StudioTool | null> => {
       });
       const path = await save(
         sandbox,
-        DIR.images,
+        artifacts,
         fileName(prompt, extOf(image.mediaType, "png")),
         image.uint8Array,
       );
@@ -172,7 +177,7 @@ const speechTool = async (): Promise<StudioTool | null> => {
     }),
     execute: async (
       { text, voice, instructions },
-      { sandbox, abortSignal },
+      { sandbox, artifacts, abortSignal },
     ) => {
       const { audio } = await generateSpeech({
         model,
@@ -184,7 +189,7 @@ const speechTool = async (): Promise<StudioTool | null> => {
       });
       const path = await save(
         sandbox,
-        DIR.audio,
+        artifacts,
         fileName(text.slice(0, 60), audio.format || "mp3"),
         audio.uint8Array,
       );
@@ -216,7 +221,7 @@ const transcribeTool = async (): Promise<StudioTool | null> => {
           "The audio file: a path relative to the workspace, or an absolute one anywhere on this machine.",
         ),
     }),
-    execute: async ({ path }, { sandbox, abortSignal }) => {
+    execute: async ({ path }, { sandbox, artifacts, abortSignal }) => {
       const audio = await readFile(sandbox.resolve(path));
       const result = await transcribe({ model, audio, abortSignal });
 
@@ -231,7 +236,7 @@ const transcribeTool = async (): Promise<StudioTool | null> => {
       const stem = basename(path, extname(path));
       const out = await save(
         sandbox,
-        DIR.transcripts,
+        artifacts,
         fileName(stem, "md"),
         Buffer.from(`# ${stem}\n\n${result.text.trim()}${timeline}\n`),
       );
@@ -273,7 +278,7 @@ const videoTool = async (): Promise<StudioTool | null> => {
     }),
     execute: async (
       { prompt, aspectRatio, seconds },
-      { sandbox, abortSignal },
+      { sandbox, artifacts, abortSignal },
     ) => {
       const { video } = await generateVideo({
         model,
@@ -284,7 +289,7 @@ const videoTool = async (): Promise<StudioTool | null> => {
       });
       const path = await save(
         sandbox,
-        DIR.videos,
+        artifacts,
         fileName(prompt, extOf(video.mediaType, "mp4")),
         video.uint8Array,
       );

package/features/ai/tools/tool-name.ts

@@ -20,11 +20,8 @@ export const TOOL_NAMES = {
   web_search: "web_search",
 
   delegate: "delegate",
-  task: "task",
-  ask_bot: "ask_bot",
-  ask_thursday: "ask_thursday",
-  ask_back: "ask_back",
-  answer: "answer",
+  thread: "thread",
+  send_message: "send_message",
 
   end_call: "end_call",
 } as const;

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

@@ -3,6 +3,7 @@ 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 { holdBotMemory, keepBotMemory } from "@/features/bot/bot.memory";
 import { writeRefusal } from "@/features/workspace/workspace";
 import type { Sandbox } from "@/lib/sandbox";
 
@@ -20,6 +21,12 @@ export const createWorkspaceTools = (
     guide?: boolean;
     /** How long one command may run; unset is the sandbox's own limit (config EXEC_TIMEOUT_MS). */
     timeoutMs?: number;
+    /**
+     * The bot this shell is for: neither tool takes its own memory past its
+     * limits (bot.memory keepBotMemory), and `write_file` starts nothing new at
+     * the top of `artifacts/` but its folder (workspace.ts writeRefusal).
+     */
+    bot?: string;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -31,6 +38,17 @@ export const createWorkspaceTools = (
   // The tool set is built per run, so one guide per run lives in this closure.
   let owed = options.guide === true;
 
+  /** Runs a step that can write, then puts back what it took past the bot's memory limits and says so. */
+  const guarded = async <T>(
+    step: () => Promise<T>,
+  ): Promise<{ result: T; memory: string | null }> => {
+    const bot = options.bot;
+    if (!bot) return { result: await step(), memory: null };
+    const held = await holdBotMemory(bot);
+    const result = await step();
+    return { result, memory: await keepBotMemory(bot, held) };
+  };
+
   const bash = tool({
     description: "Run a bash command.",
     inputSchema: z.object({
@@ -44,14 +62,17 @@ export const createWorkspaceTools = (
     }),
     // The only tool here long-running enough to be cancelled.
     execute: async ({ command }, { abortSignal }) => {
-      const result = await sandbox.exec(command, {
-        signal: abortSignal,
-        env: options.env,
-        timeoutMs: options.timeoutMs,
-      });
-      if (!owed) return result;
+      const { result, memory } = await guarded(() =>
+        sandbox.exec(command, {
+          signal: abortSignal,
+          env: options.env,
+          timeoutMs: options.timeoutMs,
+        }),
+      );
+      const answer = memory ? { ...result, memory } : result;
+      if (!owed) return answer;
       owed = false;
-      return { ...result, guide: SHELL_GUIDE };
+      return { ...answer, guide: SHELL_GUIDE };
     },
   });
 
@@ -76,10 +97,12 @@ export const createWorkspaceTools = (
     }),
     execute: async ({ path, content }) => {
       const full = sandbox.resolve(path);
-      const refusal = writeRefusal(full);
+      const refusal = writeRefusal(full, options.bot);
       if (refusal) return refusal;
-      await sandbox.writeFile(path, content);
-      return `Wrote ${short(full)} (${content.split("\n").length} lines)`;
+      const { memory } = await guarded(() => sandbox.writeFile(path, content));
+      return (
+        memory ?? `Wrote ${short(full)} (${content.split("\n").length} lines)`
+      );
     },
   });
 

package/features/artifact/artifact.action.ts

@@ -4,9 +4,9 @@ import { deleteArtifact } from "@/features/artifact/artifact.query";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
 
-/** Deletes one file a bot handed over. Reveal and open are workspace.action's. */
+/** Deletes one thing a bot handed over: a file, or a set whole. Reveal and open are workspace.action's. */
 export const deleteArtifactAction = serverAction(async (path: string) => {
   const target = path.trim();
-  if (!target) publicError("Which file?");
+  if (!target) publicError("Which artifact?");
   await deleteArtifact(target);
 });

package/features/artifact/artifact.query.ts

@@ -1,8 +1,14 @@
+import type { Dirent } from "node:fs";
 import { readdir, rm, stat } from "node:fs/promises";
-import { join, sep } from "node:path";
+import { basename, join, relative, sep } from "node:path";
 import { ARTIFACT_VIEW, PATHS } from "@/config";
+import { listBotNames } from "@/features/bot/bot.query";
 import { isListedFolder, viewKindOf } from "@/features/workspace/file-kind";
-import { ARTIFACTS, insideWorkspace } from "@/features/workspace/workspace";
+import {
+  ARTIFACTS,
+  botFolderName,
+  insideWorkspace,
+} from "@/features/workspace/workspace";
 import { publicError } from "@/lib/public-error";
 import type {
   Artifact,
@@ -12,18 +18,17 @@ import type {
 } from "./artifact.schema";
 
 /**
- * Finished work, the way the bots already file it: one entry at the top of
- * `artifacts/` is one artifact. A skill writes `artifacts/<name>.html`, a job
- * that makes a set writes `artifacts/<name>/` — so the folder is the index and
- * nothing has to be recorded anywhere.
+ * Finished work, the way the bots file it: each bot writes into its own folder,
+ * `artifacts/<bot>/`, and one entry there — a file, or a folder of several — is
+ * one artifact. What sits loose at the top of `artifacts/` (a bot's slip, or an
+ * install from before bots had folders) is listed too, belonging to nobody. So
+ * the folders are the index and nothing has to be recorded anywhere.
  *
- * Nothing here descends past the row it draws. The menu reads one folder; a set
- * reads its own when it is opened. There is no walk and no total, for the same
- * reason as Workspace: a folder's size is every file under it.
+ * Nothing here descends past the row it draws. The menu reads the top and each
+ * bot's folder; a set reads its own when it is opened. There is no walk and no
+ * total, for the same reason as Workspace: a folder's size is every file under it.
  */
 
-const relative = (name: string) => `${PATHS.artifacts}/${name}`;
-
 /**
  * The absolute path, fenced to `artifacts/`. The fence is on the resolved path,
  * never on the string that was asked for: `insideWorkspace` normalizes `..`
@@ -50,62 +55,97 @@ async function fileAt(
 }
 
 /**
- * The menu: what sits at the top of `artifacts/`, newest first. A folder costs
- * one `stat` for its date and one `readdir` for its count — never a descent,
- * so a set of thirty and a set of thirty thousand cost the same.
+ * One row: a file, or a folder as a set. A folder costs one `stat` for its date
+ * and one `readdir` for its count — never a descent, so a set of thirty and a
+ * set of thirty thousand cost the same.
+ */
+async function entryAt(
+  dir: string,
+  base: string,
+  entry: Dirent,
+  bot: string | null,
+): Promise<Artifact | null> {
+  const path = `${base}/${entry.name}`;
+
+  if (entry.isDirectory()) {
+    if (!isListedFolder(entry.name)) return null;
+    const full = join(dir, entry.name);
+    const [info, inside] = await Promise.all([
+      stat(full).catch(() => null),
+      readdir(full, { withFileTypes: true }).catch(() => []),
+    ]);
+    // Counted the way the sheet draws them, or the row promises more than it opens
+    const count = inside.filter(
+      (child) => child.isFile() && viewKindOf(child.name) !== "none",
+    ).length;
+    if (!info || count === 0) return null;
+    return {
+      name: entry.name,
+      path,
+      bot,
+      at: info.mtime,
+      kind: "set",
+      bytes: 0,
+      count,
+      view: "none",
+    };
+  }
+
+  if (!entry.isFile()) return null;
+  const file = await fileAt(dir, path, entry.name);
+  return (
+    file && {
+      name: file.name,
+      path: file.path,
+      bot,
+      at: file.at,
+      kind: "file",
+      bytes: file.bytes,
+      count: 1,
+      view: file.view,
+    }
+  );
+}
+
+/** Which bot a top-level folder belongs to, matched the way the folder was named (workspace.ts botFolderName). */
+async function botsByFolder(): Promise<Map<string, string>> {
+  const names = await listBotNames();
+  return new Map(
+    names.map((name) => [botFolderName(name).toLowerCase(), name]),
+  );
+}
+
+/**
+ * The menu: every bot's entries and the loose ones, newest first. A bot's
+ * folder is not a row of its own; its entries are, each carrying the bot.
  */
 export async function readShelf(
   limit = ARTIFACT_VIEW.rows,
 ): Promise<ArtifactShelf> {
-  const listing = await readdir(ARTIFACTS, { withFileTypes: true }).catch(
-    () => [],
-  );
+  const [listing, bots] = await Promise.all([
+    readdir(ARTIFACTS, { withFileTypes: true }).catch(() => []),
+    botsByFolder(),
+  ]);
 
   const rows = await Promise.all(
-    listing.map(async (entry): Promise<Artifact | null> => {
-      const path = relative(entry.name);
-
-      if (entry.isDirectory()) {
-        if (!isListedFolder(entry.name)) return null;
-        const full = join(ARTIFACTS, entry.name);
-        const [info, inside] = await Promise.all([
-          stat(full).catch(() => null),
-          readdir(full, { withFileTypes: true }).catch(() => []),
-        ]);
-        // Counted the way the sheet draws them, or the row promises more than it opens
-        const count = inside.filter(
-          (child) => child.isFile() && viewKindOf(child.name) !== "none",
-        ).length;
-        if (!info || count === 0) return null;
-        return {
-          name: entry.name,
-          path,
-          at: info.mtime,
-          kind: "set",
-          bytes: 0,
-          count,
-          view: "none",
-        };
-      }
-
-      if (!entry.isFile()) return null;
-      const file = await fileAt(ARTIFACTS, path, entry.name);
-      return (
-        file && {
-          name: file.name,
-          path: file.path,
-          at: file.at,
-          kind: "file",
-          bytes: file.bytes,
-          count: 1,
-          view: file.view,
-        }
+    listing.map(async (entry) => {
+      const bot = entry.isDirectory()
+        ? bots.get(entry.name.toLowerCase())
+        : undefined;
+      if (!bot) return [await entryAt(ARTIFACTS, PATHS.artifacts, entry, null)];
+
+      const dir = join(ARTIFACTS, entry.name);
+      const base = `${PATHS.artifacts}/${entry.name}`;
+      const inside = await readdir(dir, { withFileTypes: true }).catch(
+        () => [],
       );
+      return Promise.all(inside.map((child) => entryAt(dir, base, child, bot)));
     }),
   );
 
   // Newest first: the thing a bot just handed over is the thing being looked for.
   const entries = rows
+    .flat()
     .filter((row) => row !== null)
     .sort((a, b) => new Date(b.at).getTime() - new Date(a.at).getTime());
 
@@ -118,10 +158,9 @@ export async function readShelf(
 
 /** One set, opened: its files, newest first. Read only when the row is picked. */
 export async function readSet(
-  name: string,
+  path: string,
   limit = ARTIFACT_VIEW.setFiles,
 ): Promise<ArtifactSet> {
-  const path = relative(name);
   const full = await insideArtifacts(path);
 
   const listing = await readdir(full, { withFileTypes: true }).catch(
@@ -141,17 +180,29 @@ export async function readSet(
 
   return {
     path,
-    name,
+    name: basename(path),
     files: files.slice(0, limit),
     total: files.length,
   };
 }
 
-/** Deletes one artifact file. A whole set goes one file at a time, or through Workspace. */
+/**
+ * Deletes one artifact: a file, or a set with everything in it. A bot's whole
+ * folder is not an artifact, so it is refused; its entries go one at a time.
+ */
 export async function deleteArtifact(path: string): Promise<void> {
   const full = await insideArtifacts(path);
   const info = await stat(full).catch(() => null);
-  if (!info) publicError("File not found");
-  if (!info.isFile()) publicError("That is a folder, not a file");
+  if (!info) publicError("Not found");
+  if (info.isDirectory()) {
+    const inside = relative(ARTIFACTS, full);
+    if (
+      !inside.includes(sep) &&
+      (await botsByFolder()).has(inside.toLowerCase())
+    )
+      publicError("That is a bot's whole folder, not one artifact");
+    await rm(full, { recursive: true });
+    return;
+  }
   await rm(full);
 }

package/features/artifact/artifact.schema.ts

@@ -2,11 +2,11 @@ import type { FileViewKind } from "@/features/workspace/file-kind";
 import type { DateLike } from "@/lib/date-like";
 
 /**
- * What the Artifacts section reads. One row per entry at the top of
- * `artifacts/`, which is the shape the bots already write in: a skill drops
- * `artifacts/<name>.html`, a job that makes a set drops `artifacts/<name>/`.
- * So the folder is the index — nothing records what an artifact is, because
- * being there already says it.
+ * What the Artifacts section reads. One row per entry in a bot's folder,
+ * `artifacts/<bot>/`, or loose at the top of `artifacts/`: a skill drops
+ * `<name>.html`, a job that makes a set drops `<name>/`. So the folders are the
+ * index — nothing records what an artifact is or who made it, because where it
+ * is already says it.
  */
 
 /** One file inside a set, or the artifact itself when it is a lone file. */
@@ -25,6 +25,8 @@ export type Artifact = {
   /** The file's own name, or the folder's. */
   name: string;
   path: string;
+  /** The bot whose folder holds it; null when it sits loose at the top of `artifacts/`. */
+  bot: string | null;
   /** Last written; the menu sorts and bands by this. */
   at: DateLike;
   /** A folder is a set — one row however many files are in it. */
@@ -40,7 +42,7 @@ export type Artifact = {
 /** The menu, and what the rail says. */
 export type ArtifactShelf = {
   entries: Artifact[];
-  /** Everything at the top of `artifacts/`, before the page limit. */
+  /** Every row, before the page limit. */
   total: number;
   /** Files across every row, so the rail counts what the rows hide. */
   files: number;