thursday-agent 0.5.0 → 0.6.0

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;

package/features/artifact/components/artifact-setting.tsx

@@ -15,7 +15,7 @@ import {
   Trash2,
   Video,
 } from "lucide-react";
-import { useState } from "react";
+import { Fragment, useState } from "react";
 import { queryKey } from "@/app/api/query-key";
 import { Button } from "@/components/ui/button";
 import { notify } from "@/components/ui/notify";
@@ -28,6 +28,8 @@ import type {
   ArtifactSet,
   ArtifactShelf,
 } from "@/features/artifact/artifact.schema";
+import type { Bot } from "@/features/bot/bot.schema";
+import { BotMark } from "@/features/bot/components/bot-mark";
 import {
   SettingError,
   SettingFilter,
@@ -44,14 +46,14 @@ import { revalidate, useServerRoute } from "@/lib/protocol/use-server-route";
 import { cn, formatBytes } from "@/lib/utils";
 
 /*
- * What the bots finished, listed the way they 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>/`.
+ * What the bots finished, listed the way they file it: each bot writes into
+ * `artifacts/<bot>/`, and one entry there is one artifact. A skill writes
+ * `<name>.html`, a job that makes a set writes `<name>/`.
  *
  * So this is not Workspace pointed at one folder. There is no tree here: the
- * menu is flat and newest-first, and a folder does not open into another
- * listing — it opens as a sheet of what it holds, which is the thing a set of
- * pictures is for. Browsing a tree is Workspace's job.
+ * menu is newest-first under each bot's face, and a folder does not open into
+ * another listing — it opens as a sheet of what it holds, which is the thing a
+ * set of pictures is for. Browsing a tree is Workspace's job.
  */
 
 /** Every kind `viewKindOf` returns, plus the set. One icon table, as in Workspace. */
@@ -80,6 +82,7 @@ export function ArtifactSetting() {
     { keepPreviousData: true },
   );
 
+  const { data: bots } = useServerRoute<Bot[]>(queryKey.bot);
   const [reveal] = useServerAction(openFileAction);
 
   if (isLoading) return <SettingPanesSkeleton />;
@@ -89,7 +92,11 @@ export function ArtifactSetting() {
   const total = data?.total ?? 0;
   const needle = filter.trim().toLowerCase();
   const shown = needle
-    ? entries.filter((entry) => entry.name.toLowerCase().includes(needle))
+    ? entries.filter(
+        (entry) =>
+          entry.name.toLowerCase().includes(needle) ||
+          entry.bot?.toLowerCase().includes(needle),
+      )
     : entries;
 
   // A fresh row when the open one is still listed, so a rewrite shows through
@@ -130,13 +137,29 @@ export function ArtifactSetting() {
               {needle ? "Nothing matches" : "Nothing here yet"}
             </p>
           ) : (
-            shown.map((entry) => (
-              <MenuRow
-                key={entry.path}
-                entry={entry}
-                active={entry.path === picked?.path}
-                onPick={() => setReading({ row: entry, file: null })}
-              />
+            groupByBot(shown).map(({ bot, rows }) => (
+              <Fragment key={bot ?? ""}>
+                <span className="flex items-center gap-1.5 px-3 pt-3 pb-1 font-mono text-[10px] text-muted-foreground/60">
+                  {bot && (
+                    <BotMark
+                      size={12}
+                      seed={bot}
+                      {...markOf(bot, bots)}
+                      notify={false}
+                      className="shrink-0"
+                    />
+                  )}
+                  <span className="truncate">{bot ?? "Unsorted"}</span>
+                </span>
+                {rows.map((entry) => (
+                  <MenuRow
+                    key={entry.path}
+                    entry={entry}
+                    active={entry.path === picked?.path}
+                    onPick={() => setReading({ row: entry, file: null })}
+                  />
+                ))}
+              </Fragment>
             ))
           )}
 
@@ -170,6 +193,33 @@ export function ArtifactSetting() {
   );
 }
 
+/**
+ * Rows under the bot that made them, in the order the rows came: newest first,
+ * so the bot that handed something over last is on top. Loose rows are one group.
+ */
+function groupByBot(
+  entries: Artifact[],
+): { bot: string | null; rows: Artifact[] }[] {
+  const groups = new Map<string | null, Artifact[]>();
+  for (const entry of entries) {
+    const rows = groups.get(entry.bot) ?? [];
+    rows.push(entry);
+    groups.set(entry.bot, rows);
+  }
+  return [...groups].map(([bot, rows]) => ({ bot, rows }));
+}
+
+/** Icon from the bot list; the row only carries the name. A bot that is gone draws its seed alone. */
+function markOf(name: string, bots?: Bot[]) {
+  const icon = bots?.find((bot) => bot.name === name)?.icon;
+  return {
+    color: icon?.color,
+    shape: icon?.shape,
+    outline: icon?.outline,
+    paint: icon?.paint,
+  };
+}
+
 /** `4 artifacts · 34 files`, and what is not on screen. Counts rows, so it is free. */
 function countLine(shown: Artifact[], total: number, files: number): string {
   if (total === 0) return "empty";
@@ -247,7 +297,9 @@ function Reader({
   const confirmRemove = async (path: string) => {
     const confirmed = await notify.confirm({
       title: `Delete ${path.split("/").pop()}?`,
-      description: "It is deleted from disk for good.",
+      description: open
+        ? "It is deleted from disk for good."
+        : "The folder and everything in it are deleted from disk for good.",
       okText: "Delete",
       destructive: true,
     });
@@ -295,25 +347,23 @@ function Reader({
         >
           <FolderOpen />
         </Button>
-        {open && (
-          <Button
-            size="icon-sm"
-            variant="ghost"
-            aria-label="Delete"
-            loading={removing}
-            className="text-muted-foreground"
-            onClick={() => confirmRemove(open.path)}
-          >
-            <Trash2 />
-          </Button>
-        )}
+        <Button
+          size="icon-sm"
+          variant="ghost"
+          aria-label="Delete"
+          loading={removing}
+          className="text-muted-foreground"
+          onClick={() => confirmRemove(open?.path ?? row.path)}
+        >
+          <Trash2 />
+        </Button>
       </div>
 
       <div className="min-h-0 flex-1 overflow-auto">
         {open ? (
           <FilePreview path={open.path} bytes={open.bytes} />
         ) : (
-          <SetSheet name={row.name} onOpen={onOpen} />
+          <SetSheet path={row.path} onOpen={onOpen} />
         )}
       </div>
     </>
@@ -325,14 +375,14 @@ function Reader({
  * a set nobody opens costs one `readdir` for its count and nothing more.
  */
 function SetSheet({
-  name,
+  path,
   onOpen,
 }: {
-  name: string;
+  path: string;
   onOpen: (file: ArtifactFile) => void;
 }) {
   const { data, isLoading, error } = useServerRoute<ArtifactSet>(
-    queryKey.artifactSet(name, ARTIFACT_VIEW.setFiles),
+    queryKey.artifactSet(path, ARTIFACT_VIEW.setFiles),
   );
 
   if (isLoading) {
@@ -418,7 +468,7 @@ function Nothing({
       <p className="max-w-lg text-sm leading-relaxed text-muted-foreground">
         {empty
           ? "Nothing finished yet. When a bot ends a job with something to hand over — a page, a report, a set of pictures — it lands here."
-          : "Pick something on the left. A folder a bot filled is one row, and opens as a sheet."}
+          : "Pick something on the left. Each bot's work is under its face; a folder it filled is one row, and opens as a sheet."}
       </p>
       <Button variant="outline" onClick={onReveal}>
         <FolderOpen />