thursday-agent 0.4.0 → 0.5.0

package/features/ai/prompts/bot.prompt.ts

@@ -232,7 +232,7 @@ function methods(skills: SkillMetadata[]): string {
 
   return `## Skills
 
-Written-down methods. When the job is one of these, read it with \`${TOOL_NAMES.load_skill}\` before starting.
+Written-down methods. Use the instructions already in your conversation. When the job needs a skill whose full instructions are absent, read it with \`${TOOL_NAMES.load_skill}\` before starting.
 
 ${skillLines(skills)}`;
 }

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

@@ -34,12 +34,12 @@ export const delegateSpec = {
 
 /**
  * `context` carries what the asking bot found, since its thread is not handed over (bot.run).
- * `request` is a brief, not a line: the borrowed bot sees nothing else.
+ * A returning participant keeps its own thread; `context` adds only what this caller knows.
  */
 export const askBotSpec = {
   name: TOOL_NAMES.ask_bot,
   description:
-    "Hand one part of the job you are holding to another bot and wait for what they bring back. The job stays yours.",
+    "Send a request to another bot on this job and wait for their reply. The same bot continues its own work and conversation whenever you ask it again. The job stays yours.",
   parameters: z.object({
     bot: z.string().describe("A name from the bot list."),
     request: z
@@ -50,7 +50,7 @@ export const askBotSpec = {
     context: z
       .string()
       .describe(
-        "What you have done on the job so far and why this part is theirs — exact values, and the paths of files you wrote for them to read. They see this, the part, the job and the call; not your thread or your tool output, so a value you leave out is one they fetch again.",
+        "Pass on what you know that they do not: exact values and paths they need. They keep their own previous work and your exchanges, but cannot read your private thread or tool output.",
       ),
   }),
 };

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

@@ -6,9 +6,8 @@ import { splitFrontmatter } from "@/features/skills/skills.query";
 import type { Sandbox } from "@/lib/sandbox";
 
 /**
- * A skill's full text is returned once per run; repeat loads get a pointer
- * back to the first result, since every step resends the whole context.
- * The tool set is built per run, so the `loaded` set lives in this closure.
+ * Reuse instructions only while their full text remains in this bot's context.
+ * A resume can carry them; compaction can remove them.
  */
 export const createSkillTools = ({
   skills,
@@ -17,7 +16,6 @@ export const createSkillTools = ({
   skills: SkillMetadata[];
   sandbox: Sandbox;
 }) => {
-  const loaded = new Set<string>();
   return {
     [TOOL_NAMES.load_skill]: tool({
       description:
@@ -29,7 +27,7 @@ export const createSkillTools = ({
             "Exact name from the Skills list. Do not guess names that are not on it.",
           ),
       }),
-      execute: async ({ name }) => {
+      execute: async ({ name }, { messages }) => {
         const skill = skills.find(
           (s) => s.name.toLowerCase() === name.toLowerCase(),
         );
@@ -41,10 +39,30 @@ export const createSkillTools = ({
         }
 
         const skillFile = `${skill.path}/SKILL.md`;
-        if (loaded.has(skill.path)) {
+        const carried = messages.some(
+          (message) =>
+            Array.isArray(message.content) &&
+            message.content.some((part) => {
+              if (
+                part.type !== "tool-result" ||
+                part.toolName !== TOOL_NAMES.load_skill ||
+                part.output.type !== "json"
+              )
+                return false;
+              const value = part.output.value as {
+                skillDirectory?: string;
+                content?: string;
+              } | null;
+              return (
+                value?.skillDirectory === skill.path &&
+                typeof value.content === "string"
+              );
+            }),
+        );
+        if (carried) {
           return {
             skillDirectory: skill.path,
-            note: `You already loaded '${skill.name}' in this run — its instructions are above, unchanged. Scroll back to that result rather than reading it again; if you need the file itself, read ${skillFile} with the shell.`,
+            note: `Use the full '${skill.name}' instructions already in your conversation. To check for changes on disk, read ${skillFile} with the shell.`,
           };
         }
 
@@ -55,7 +73,6 @@ export const createSkillTools = ({
           path: skill.path,
           limit: 50,
         });
-        loaded.add(skill.path);
 
         return {
           skillDirectory: skill.path,

package/features/bot/bot.run.ts

@@ -41,17 +41,21 @@ import {
   type TokenUsage,
 } from "@/features/bot/bot.schema";
 import {
-  closeHiddenBrowser,
+  botBrowserSession,
   filesOnDisk,
   openBotFolder,
   openJobScratch,
 } from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { publicError } from "@/lib/public-error";
+import { createKeyedLock } from "@/lib/queue";
 import { estimateTokens } from "@/lib/tokens";
+import { PromiseChain } from "@/lib/utils";
 import { findJobBot } from "./bot.query";
 import {
   findTask,
+  listBorrowedTails,
+  listBotThread,
   listWrittenPaths,
   optionsOf,
   writtenPathsIn,
@@ -65,6 +69,11 @@ import {
 
 /** One thing that happened in a run. The runner adds which bot and inside which `ask_bot` call. */
 export type BotEvent =
+  /** A request enters this participant's own thread before its model runs. */
+  | {
+      type: "request";
+      content: Extract<ModelMessage, { role: "user" }>["content"];
+    }
   /** A finished chunk of prose. */
   | { type: "text"; text: string }
   /** A tool call. `id` is where the result lands. */
@@ -147,6 +156,8 @@ export type RunOptions = {
    * in one window.
    */
   session?: string | null;
+  /** Shared by every participant in this live segment; history itself lives in the DB. */
+  desks?: ReturnType<typeof createBotDesks>;
   /**
    * Drained once per step boundary; each string goes in front of the model as
    * a user turn before the next step. Only the job's own bot has one.
@@ -189,11 +200,11 @@ export async function runBot(
 ): Promise<void> {
   const depth = options.depth ?? 0;
   const parent = options.parent ?? null;
-  const name = input.bot.trim();
+  const bot = await findJobBot(input.bot.trim());
+  const name = bot?.name ?? input.bot.trim();
   const emit = (event: BotEvent) =>
     options.emit({ ...event, bot: name, parent });
 
-  const bot = await findJobBot(name);
   if (!bot) {
     await emit({
       type: "error",
@@ -205,7 +216,11 @@ export async function runBot(
   // Switched off is not a bot to pick — the backstop for every fresh start
   // (`delegate`, `ask_bot`, the screen). A resume carries `messages` instead and
   // is let through: its thread already exists and the user can still answer it.
-  if (bot.disabled && "request" in input) {
+  const previous =
+    "askedBy" in input && options.taskId
+      ? await listBotThread(options.taskId, name)
+      : [];
+  if (bot.disabled && "request" in input && !previous.length) {
     await emit({
       type: "error",
       message: `${bot.name} is switched off. Use a name from the list.`,
@@ -214,6 +229,30 @@ export async function runBot(
     return;
   }
 
+  options = { ...options, desks: options.desks ?? createBotDesks() };
+  let history: ModelMessage[];
+  if ("messages" in input) {
+    history = input.messages;
+  } else {
+    const content = previous.length
+      ? `## ${input.askedBy} → ${name}: the next request\n\n${input.request.trim()}${input.context?.trim() ? `\n\n## What ${input.askedBy} passes on\n\n${input.context.trim()}` : ""}`
+      : buildHandoff({
+          chain: input.chain,
+          bots: [...input.above, name],
+          did: input.context ?? null,
+          part: input.request,
+        });
+    history = [
+      ...resumeThread(
+        previous,
+        options.taskId ? await listBorrowedTails(options.taskId) : undefined,
+      ),
+      { role: "user", content },
+    ];
+    options.signal?.throwIfAborted();
+    await emit({ type: "request", content });
+  }
+
   // Tools are built on the model: web search runs on this bot's model (load-tools).
   const model = await resolveModel(bot);
   // The job's row: the same one for every seat on the job, a borrowed bot's too
@@ -254,21 +293,6 @@ export async function runBot(
     ("askedBy" in input ? 0 : row?.contextBudget) || Number.POSITIVE_INFINITY,
   );
 
-  const history: ModelMessage[] =
-    "messages" in input
-      ? input.messages
-      : [
-          {
-            role: "user",
-            content: buildHandoff({
-              chain: input.chain,
-              bots: [...input.above, name],
-              did: input.context ?? null,
-              part: input.request,
-            }),
-          },
-        ];
-
   /** Remaining `ask_back` calls for a borrowed bot; the tool counts it down. */
   const asks = { left: BOT_RUN.askBack };
   // A borrowed bot asks back instead of asking Thursday. Any seat above the
@@ -879,15 +903,20 @@ export async function runBotToText(
   await runBot(input, {
     ...options,
     emit: async (event) => {
-      if (event.type === "answer") {
+      if (
+        event.parent === (options.parent ?? null) &&
+        event.type === "answer"
+      ) {
         outcome = event.stopped
           ? `${event.text}\n\n(As far as they got — they stopped before finishing.)`
           : event.text;
       }
-      if (event.type === "error") failure = event.message;
+      if (event.parent === (options.parent ?? null) && event.type === "error")
+        failure = event.message;
       await options.emit(event);
     },
   });
+  options.signal?.throwIfAborted();
   if (failure) publicError(failure);
   return outcome;
 }
@@ -918,6 +947,11 @@ function withAskBot(
   },
 ): ToolSet {
   if (asker.peers.length === 0) return tools;
+  // Calls made in the same step answer from one evolving conversation.
+  const conversations = new WeakMap<
+    ModelMessage[],
+    { messages: ModelMessage[]; answer: ReturnType<typeof PromiseChain> }
+  >();
 
   const agentTools: ToolSet = {
     ...tools,
@@ -925,66 +959,143 @@ function withAskBot(
       description: askBotSpec.description,
       inputSchema: askBotSpec.parameters,
       execute: async ({ bot, request, context }, call) => {
-        // A bot above is blocked waiting on this very call; borrowing it back never returns
+        const found = await findJobBot(bot);
+        if (!found) return `No bot named "${bot}". Use a name from the list.`;
+        bot = found.name;
         if (bot === asker.name || asker.above.includes(bot)) {
-          return `${bot} is already on this job, above you and waiting on your part. Pick another bot, or do it yourself.`;
-        }
-        // The borrowed bot works in the job's folder but drives a browser session
-        // of its own, under this call's id. When it answers, the same rule as a
-        // job's end: what it showed on their screen stays, what nobody can see
-        // closes (workspace.ts closeHiddenBrowser).
-        const session = asker.options.taskId
-          ? `${asker.options.session ?? asker.options.taskId}-${call.toolCallId.slice(0, 8)}`
-          : null;
-        const exchanges: { question: string; answer: string }[] = [];
-        const answer = async (question: string) => {
-          const reply = await answerBack({
-            model: asker.model,
-            instructions: asker.instructions,
-            // Same tools, calling off (see compact).
-            tools: agentTools,
-            messages: call.messages,
-            asked: { bot, request },
-            question,
-            signal: asker.options.signal,
-          });
-          await asker.emit({ type: "answered", question, ...reply });
-          exchanges.push({ question, answer: reply.text });
-          return reply.text;
-        };
-        try {
-          const outcome = await runBotToText(
-            {
-              bot,
-              request,
-              context,
-              askedBy: asker.name,
-              chain: asker.chain,
-              above: [...asker.above, asker.name],
-            },
-            {
-              ...asker.options,
-              // This call's signal, not the job's: a stream that ends — the job
-              // stopping, or the model going quiet — ends the part it waited on
-              signal: call.abortSignal ?? asker.options.signal,
-              depth: asker.depth + 1,
-              parent: call.toolCallId,
-              session,
-              answer,
-            },
-          );
-          return exchanges.length
-            ? `${outcome}\n\n${exchangeLines(bot, exchanges)}`
-            : outcome;
-        } finally {
-          if (session) void closeHiddenBrowser(session);
+          return `${bot} is already above you and waiting on this part. Use ask_back for a question, or pick another bot.`;
         }
+        const signal = call.abortSignal ?? asker.options.signal;
+        const desks = asker.options.desks!;
+        return desks.run(asker.name, bot, signal, async () => {
+          const session = asker.options.taskId
+            ? botBrowserSession(asker.options.taskId, bot)
+            : null;
+          const exchanges: { question: string; answer: string }[] = [];
+          let conversation = conversations.get(call.messages);
+          if (!conversation) {
+            conversation = {
+              messages: [...call.messages],
+              answer: PromiseChain(),
+            };
+            conversations.set(call.messages, conversation);
+          }
+          const current = conversation;
+          const answer = (question: string) =>
+            current.answer(async () => {
+              signal?.throwIfAborted();
+              const reply = await answerBack({
+                model: asker.model,
+                instructions: asker.instructions,
+                tools: agentTools,
+                messages: current.messages,
+                asked: { bot, request },
+                question,
+                signal,
+              });
+              current.messages.push(
+                {
+                  role: "user",
+                  content: `${bot} asks about the part you handed over:\n\n${question}`,
+                },
+                { role: "assistant", content: reply.text },
+              );
+              await asker.emit({ type: "answered", question, ...reply });
+              exchanges.push({ question, answer: reply.text });
+              return reply.text;
+            });
+          try {
+            const outcome = await runBotToText(
+              {
+                bot,
+                request,
+                context,
+                askedBy: asker.name,
+                chain: asker.chain,
+                above: [...asker.above, asker.name],
+              },
+              {
+                ...asker.options,
+                signal,
+                depth: asker.depth + 1,
+                parent: call.toolCallId,
+                session,
+                // Only the task's owner drains words sent by the user.
+                notes: undefined,
+                answer,
+              },
+            );
+            return exchanges.length
+              ? `${outcome}\n\n${exchangeLines(bot, exchanges)}`
+              : outcome;
+          } catch (cause) {
+            signal?.throwIfAborted();
+            publicError(
+              [modelErrorToString(cause), exchangeLines(bot, exchanges)]
+                .filter(Boolean)
+                .join("\n\n"),
+            );
+          }
+        });
       },
     }),
   };
   return agentTools;
 }
 
+/** One execution per participant, with wait-cycle detection across concurrent branches. */
+export function createBotDesks() {
+  const lock = createKeyedLock();
+  const waiting = new Map<string, Map<string, number>>();
+  const pending = new Set<Promise<unknown>>();
+  const reaches = (
+    from: string,
+    to: string,
+    seen = new Set<string>(),
+  ): boolean => {
+    if (from === to) return true;
+    if (seen.has(from)) return false;
+    seen.add(from);
+    return [...(waiting.get(from)?.keys() ?? [])].some((next) =>
+      reaches(next, to, seen),
+    );
+  };
+  return {
+    async run<T>(
+      from: string,
+      to: string,
+      signal: AbortSignal | undefined,
+      work: () => Promise<T>,
+    ): Promise<T> {
+      signal?.throwIfAborted();
+      if (reaches(to, from))
+        publicError(
+          `${to} is waiting on your work. Finish this part before asking them, or choose another bot.`,
+        );
+      const edges = waiting.get(from) ?? new Map<string, number>();
+      waiting.set(from, edges);
+      edges.set(to, (edges.get(to) ?? 0) + 1);
+      const run = lock(to, async () => {
+        signal?.throwIfAborted();
+        return work();
+      });
+      pending.add(run);
+      try {
+        return await run;
+      } finally {
+        pending.delete(run);
+        const left = (edges.get(to) ?? 1) - 1;
+        if (left) edges.set(to, left);
+        else edges.delete(to);
+        if (!edges.size) waiting.delete(from);
+      }
+    },
+    async settle() {
+      while (pending.size) await Promise.allSettled([...pending]);
+    },
+  };
+}
+
 /** Appended under the answer: what the borrowed bot asked and what this bot answered. */
 function exchangeLines(
   bot: string,

package/features/bot/bot.runner.ts

@@ -33,7 +33,12 @@ import { desktopNotify } from "@/lib/desktop-notify";
 import { logger } from "@/lib/logger";
 import { publicError } from "@/lib/public-error";
 import { createKeyedLock } from "@/lib/queue";
-import { resumeThread, runBot, type TaskEvent } from "./bot.run";
+import {
+  createBotDesks,
+  resumeThread,
+  runBot,
+  type TaskEvent,
+} from "./bot.run";
 import {
   TASK_CONTINUE,
   type TaskPending,
@@ -44,7 +49,6 @@ import {
 import {
   addTaskUsage,
   countStopsSinceSpoken,
-  deleteFinishedTasks,
   deleteMessages,
   deleteTask,
   findTask,
@@ -275,7 +279,8 @@ export async function cancelTask(id: string) {
     // write "Cancelled." over the thing it was run for.
     if (task.endedAt) publicError("That job has already ended.");
     forgetResume(id);
-    running.get(id)?.stop.abort();
+    const live = running.get(id);
+    live?.stop.abort();
     await updateTask(id, {
       status: "failed",
       outcome: "Cancelled.",
@@ -286,24 +291,27 @@ export async function cancelTask(id: string) {
     });
     // Cancel is a real end, so the browser session closes here; the abort in
     // answerTask is followed by a relaunch and must not close it.
-    void closeJobShell(id);
+    await live?.done;
+    await closeJobShell(id);
   });
 }
 
 /** Deletes the job, stopping it first if it is still running. */
 export async function removeTask(id: string) {
-  return taskLock(id, async () => {
-    const task = await findTask(id);
-    forgetResume(id);
-    running.get(id)?.stop.abort();
-    running.delete(id);
-    void closeJobShell(id);
-    const gone = await deleteTask(id);
-    // The working folder's lifetime is the row's: with the job gone, what it was
-    // working with is nobody's (workspace.ts jobScratch).
-    if (gone && task) await removeJobScratch(id, task.label);
-    return gone;
-  });
+  return taskLock(id, () => removeLockedTask(id));
+}
+
+/** The caller holds taskLock, so a follow-up cannot race deletion or browser cleanup. */
+async function removeLockedTask(id: string) {
+  const task = await findTask(id);
+  forgetResume(id);
+  const live = running.get(id);
+  live?.stop.abort();
+  await live?.done;
+  await closeJobShell(id);
+  const gone = await deleteTask(id);
+  if (gone && task) await removeJobScratch(id, task.label);
+  return gone;
 }
 
 /**
@@ -312,9 +320,16 @@ export async function removeTask(id: string) {
  * and only one of the two is the database's.
  */
 export async function removeFinishedTasks(): Promise<number> {
-  const removed = await deleteFinishedTasks();
-  for (const task of removed) await removeJobScratch(task.id, task.label);
-  return removed.length;
+  let removed = 0;
+  for (const task of await listTaskFolders()) {
+    if (task.status !== "done" && task.status !== "failed") continue;
+    await taskLock(task.id, async () => {
+      const current = await findTask(task.id);
+      if (current?.status !== "done" && current?.status !== "failed") return;
+      if (await removeLockedTask(task.id)) removed += 1;
+    });
+  }
+  return removed;
 }
 
 /**
@@ -345,6 +360,7 @@ export async function sweepJobFiles(): Promise<string[]> {
     await taskLock(task.id, async () => {
       const now = await findTask(task.id);
       if (!now || !stale(now)) return;
+      await closeHiddenBrowser(task.id);
       await removeJobScratch(task.id, task.label);
       removed.push(folder);
     });
@@ -652,6 +668,12 @@ class ThreadWriter {
     if (this.closed) return;
     const step = this.step(event);
     switch (event.type) {
+      case "request":
+        return this.write(++this.seq, event, {
+          role: "user",
+          content: event.content,
+        });
+
       case "text":
         step.assistant ??= ++this.seq;
         step.parts.assistant.push({ type: "text", text: event.text });
@@ -747,6 +769,7 @@ async function drive(
   notes: string[],
 ) {
   const thread = new ThreadWriter(id, await lastSeq(id));
+  const desks = createBotDesks();
 
   let ending: {
     status: TaskStatus;
@@ -767,6 +790,7 @@ async function drive(
     await runBot(input, {
       signal,
       taskId: id,
+      desks,
       notes: () => notes.splice(0),
       emit: async (event) => {
         await thread.on(event);
@@ -829,6 +853,8 @@ async function drive(
       pending: null,
     };
   } finally {
+    // A resumed segment cannot overtake a participant still unwinding its tools.
+    await desks.settle();
     thread.close();
     running.delete(id);
   }
@@ -881,10 +907,9 @@ async function drive(
     return;
   }
 
-  // A waiting job keeps its browser: answering resumes into the page it left
-  // off at. An ended one closes only what nobody can see (closeHiddenBrowser).
-  if (park || final.status === "waiting") void pruneJobFiles();
-  else void closeHiddenBrowser(id);
+  // Follow-ups can reopen a completed job. Its participants keep their browsers
+  // until cancellation, deletion, or the workspace retention sweep.
+  void pruneJobFiles();
 
   const task = await findTask(id);
   if (!task) return;