thursday-agent 0.3.0 → 0.5.0

package/features/bot/bot.runner.ts

@@ -33,12 +33,22 @@ 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 { TASK_CONTINUE, type TaskPending, type TaskStatus } from "./bot.schema";
+import {
+  createBotDesks,
+  resumeThread,
+  runBot,
+  type TaskEvent,
+} from "./bot.run";
+import {
+  TASK_CONTINUE,
+  type TaskPending,
+  type TaskSpeaker,
+  type TaskStatus,
+  tagSpeaker,
+} from "./bot.schema";
 import {
   addTaskUsage,
   countStopsSinceSpoken,
-  deleteFinishedTasks,
   deleteMessages,
   deleteTask,
   findTask,
@@ -49,6 +59,7 @@ import {
   listRunningTaskIds,
   listTaskFolders,
   listThread,
+  stopNote,
   type TaskMessageInput,
   updateTask,
   upsertMessage,
@@ -99,24 +110,28 @@ const pausing = ((globalThis as Pinned).__botPausing ??= {
   current: Promise.resolve(),
 });
 
-/** Opens a job. The opening message — who is who, the job, the call it came from (bot.prompt buildTaskOpening) — is the thread's first row. */
+/** Opens a job. The opening message — who is on it, the job, the call it came from (bot.prompt buildTaskOpening) — is the thread's first row. */
 export async function startTask(input: {
   bot: string;
   request: string;
   label: string;
   callId?: string | null;
+  /** Who handed it over: Thursday during a call, or the user on screen. */
+  from: TaskSpeaker;
 }) {
-  const conversation = input.callId
-    ? await listCallTurns(input.callId, OPENING_TURNS)
+  const { from, ...row } = input;
+  const conversation = row.callId
+    ? await listCallTurns(row.callId, OPENING_TURNS)
     : [];
   const opening = buildTaskOpening({
-    bot: input.bot,
-    request: input.request,
+    bot: row.bot,
+    request: row.request,
     conversation,
+    from,
   });
-  const task = await insertTask({ ...input, opening });
+  const task = await insertTask({ ...row, opening });
   launch(task.id, {
-    bot: input.bot,
+    bot: row.bot,
     messages: [{ role: "user", content: opening }],
   });
   return task.id;
@@ -128,14 +143,25 @@ export async function startTask(input: {
  * before its next step; the step in flight finishes), or a follow-up to a
  * finished one. Only when the run has already ended does the running case
  * fall through to stop, append, relaunch.
+ *
+ * @param from Who said it. The words go on the thread tagged with it (bot.schema
+ * tagSpeaker): Thursday passing something on from a call and the user typing on
+ * screen reach the bot down this one pipe, and a go-ahead means something
+ * different from each. Unset for words that already carry their tags — the notes
+ * a finished run left unread (drive).
  */
-export async function answerTask(id: string, answer: string) {
+export async function answerTask(
+  id: string,
+  answer: string,
+  from?: TaskSpeaker,
+) {
+  const said = from ? tagSpeaker(from, answer) : answer;
   return taskLock(id, async () => {
     const task = await findTask(id);
     if (!task) publicError("No such job.");
 
     const live = running.get(id);
-    if (live && task.status === "running" && live.note(answer)) {
+    if (live && task.status === "running" && live.note(said)) {
       logger.debug(`task ${id}: interjection queued`);
       return;
     }
@@ -147,7 +173,7 @@ export async function answerTask(id: string, answer: string) {
     forgetResume(id);
 
     const thread = await listThread(id);
-    const { reply, as } = joinThread(task, answer, thread);
+    const { reply, as } = joinThread(task, said, thread);
     logger.debug(`task ${id}: ${as}`);
 
     await upsertMessage(id, (await lastSeq(id)) + 1, {
@@ -253,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.",
@@ -264,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;
 }
 
 /**
@@ -290,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;
 }
 
 /**
@@ -323,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);
     });
@@ -465,7 +503,7 @@ async function parkTask(
   const inMs =
     auto && stop.retry ? waits[Math.min(stops, waits.length - 1)] : 0;
 
-  await writeNote(id, `${stop.why} ${IN_FLIGHT}`).catch((cause) =>
+  await writeNote(id, stopNote(stop.why)).catch((cause) =>
     logger.warn(`task ${id}: stop not written`, cause),
   );
   await writeEnding(id, {
@@ -485,10 +523,6 @@ async function parkTask(
   if (auto) scheduleResume(id, inMs);
 }
 
-/** Said to a resumed run after why it stopped. */
-const IN_FLIGHT =
-  "Anything that was under way — a command, a page loading, a download — may not have finished: check before relying on it, then carry on.";
-
 const spell = (ms: number) =>
   ms < 60_000
     ? `${Math.round(ms / 1000)} seconds`
@@ -634,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 });
@@ -729,6 +769,7 @@ async function drive(
   notes: string[],
 ) {
   const thread = new ThreadWriter(id, await lastSeq(id));
+  const desks = createBotDesks();
 
   let ending: {
     status: TaskStatus;
@@ -749,6 +790,7 @@ async function drive(
     await runBot(input, {
       signal,
       taskId: id,
+      desks,
       notes: () => notes.splice(0),
       emit: async (event) => {
         await thread.on(event);
@@ -811,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);
   }
@@ -863,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;

package/features/bot/bot.schema.ts

@@ -205,6 +205,29 @@ export const TASK_HISTORY_PAGE = PAGE_SIZE;
 /** The single option offered when the app stopped a job and asks whether to go on. Button text and spoken word alike. */
 export const TASK_CONTINUE = "Continue";
 
+/**
+ * Who a person's words to a job came from (bot.runner answerTask). Thursday
+ * passing something on from a call and the user typing on screen reach a bot
+ * down one pipe, so the words carry it in front of them.
+ */
+export type TaskSpeaker = "thursday" | "user";
+
+const SPEAKER_TAGS: Record<TaskSpeaker, string> = {
+  thursday: "Thursday, on the call:",
+  user: "The user, on screen:",
+};
+
+export const tagSpeaker = (from: TaskSpeaker, text: string): string =>
+  `${SPEAKER_TAGS[from]} ${text}`;
+
+/** The words without their tag, as the screen draws a person's line (task.query linesOf). */
+export const untagSpeaker = (text: string): string => {
+  for (const tag of Object.values(SPEAKER_TAGS)) {
+    if (text.startsWith(`${tag} `)) return text.slice(tag.length + 1);
+  }
+  return text;
+};
+
 /**
  * What a `waiting` job waits on (database task.pending). `toolCallId` is the
  * `ask_thursday` call the answer resolves, null when the app stopped the run and
@@ -254,6 +277,8 @@ export const TaskLineSchema = z.discriminatedUnion("kind", [
   LineBase.extend({ kind: z.literal("text"), text: z.string() }),
   /** Compaction summary (bot.run compact). The model resumes from here; the screen draws it as a divider. */
   LineBase.extend({ kind: z.literal("note"), text: z.string() }),
+  /** Why the app stopped the run (bot.runner parkTask, a run that broke), without what the resumed run is told to check. */
+  LineBase.extend({ kind: z.literal("stop"), text: z.string() }),
   LineBase.extend({
     kind: z.literal("tool"),
     callId: z.string(),

package/features/bot/components/bot-room.tsx

@@ -1,8 +1,10 @@
 "use client";
 
+import { format } from "date-fns";
 import {
   ArrowUp,
   Check,
+  ChevronDown,
   ChevronLeft,
   ChevronRight,
   ChevronsRight,
@@ -10,6 +12,7 @@ import {
   History,
   Loader2,
   Plus,
+  RotateCw,
   X,
 } from "lucide-react";
 import {
@@ -45,7 +48,7 @@ import { TaskReply, useAnswerTask } from "@/features/bot/components/task-reply";
 import { openSettings } from "@/features/settings/settings.store";
 import { ThursdayMark } from "@/features/thursday/components/thursday-mark";
 import { FileViewer } from "@/features/workspace/components/file-view";
-import { shortAgo } from "@/lib/date-like";
+import { shortAgo, toDate } from "@/lib/date-like";
 import { useServerAction } from "@/lib/protocol/use-server-action";
 import { revalidate, useServerRoute } from "@/lib/protocol/use-server-route";
 import {
@@ -1630,6 +1633,8 @@ function Group({ group, task }: { group: ChatterGroup; task: TaskView }) {
         {runs(group.lines).map((run) =>
           run.kind === "tools" ? (
             <Steps key={run.key} lines={run.lines} taskId={task.id} />
+          ) : run.kind === "stops" ? (
+            <Stops key={run.key} lines={run.lines} />
           ) : (
             run.lines.map((line) => (
               <Line key={line.id} line={line} taskId={task.id} />
@@ -1793,17 +1798,65 @@ function Steps({ lines, taskId }: { lines: Chatter[]; taskId: string }) {
   );
 }
 
-/** Splits one speaker's lines into runs of tool calls and runs of everything else. */
+/**
+ * Where the app stopped the run (bot.runner parkTask): a failed model call, a
+ * restart, a closed browser. Muted and in the bot's turn, since the bot goes on
+ * from here. The same reason in a row is one line with a count; opening it lists
+ * each stop by the time it happened.
+ */
+function Stops({ lines }: { lines: Chatter[] }) {
+  return (
+    <details className="group min-w-0 px-1 text-muted-foreground">
+      <summary className="flex cursor-pointer list-none items-center gap-1.5 text-[12.5px] leading-relaxed outline-none [&::-webkit-details-marker]:hidden">
+        <RotateCw className="size-3 shrink-0" />
+        <span className="min-w-0 truncate">{leadOf(lines[0].text)}</span>
+        {lines.length > 1 && (
+          <span className="shrink-0 font-mono text-[10px] text-muted-foreground/70">
+            ×{lines.length}
+          </span>
+        )}
+        <ChevronDown className="size-2.5 shrink-0 text-muted-foreground/70 transition-transform group-open:rotate-180" />
+      </summary>
+      <div className="mt-1 space-y-1 pl-4.5 text-[11px] leading-relaxed">
+        {lines.map((line) => (
+          <p key={line.id} className="flex gap-2 break-keep">
+            {line.at && (
+              <span className="shrink-0 font-mono text-muted-foreground/70 tabular-nums">
+                {format(toDate(line.at), "HH:mm:ss")}
+              </span>
+            )}
+            <span className="min-w-0">{line.text}</span>
+          </p>
+        ))}
+      </div>
+    </details>
+  );
+}
+
+/** What stopped it, without the words behind it: a stop names those in parentheses (bot.runner parkTask). */
+const leadOf = (text: string) => text.split(" (")[0].replace(/\.$/, "");
+
+/** Splits one speaker's lines into runs of tool calls, of stops, and of everything else. */
 type Run =
   | { kind: "tools"; key: string; lines: Chatter[] }
+  | { kind: "stops"; key: string; lines: Chatter[] }
   | { kind: "said"; key: string; lines: Chatter[] };
 
 function runs(lines: Chatter[]): Run[] {
   const out: Run[] = [];
   for (const line of lines) {
-    const kind = line.kind === "tool" && line.tool ? "tools" : "said";
+    const kind =
+      line.kind === "tool" && line.tool
+        ? "tools"
+        : line.kind === "stop"
+          ? "stops"
+          : "said";
     const open = out.at(-1);
-    if (open && open.kind === kind) open.lines.push(line);
+    // Stops fold only while the reason repeats; another reason is a line of its own
+    const same =
+      open?.kind === kind &&
+      (kind !== "stops" || leadOf(open.lines[0].text) === leadOf(line.text));
+    if (open && same) open.lines.push(line);
     else out.push({ kind, key: line.id, lines: [line] });
   }
   return out;

package/features/bot/components/bot-tool.tsx

@@ -64,7 +64,6 @@ const TOOL_ICONS: Record<string, LucideIcon> = {
   memory_recall: MemoryMark,
   memory_remember: MemoryMark,
   memory_forget: MemoryMark,
-  memory_show: MemoryMark,
   load_skill: SkillsMark,
   tool_search: McpMark,
   tool_call: McpMark,

package/features/bot/task.query.ts

@@ -25,6 +25,7 @@ import {
   type TaskPending,
   type TaskStatus,
   type TokenUsage,
+  untagSpeaker,
 } from "./bot.schema";
 
 // Tasks and their threads. Bots themselves (roster, pinned tools) are bot.query.
@@ -343,21 +344,23 @@ export async function listBorrowedTails(
       and(
         eq(taskMessageTable.taskId, taskId),
         isNotNull(taskMessageTable.parent),
-        eq(taskMessageTable.role, "assistant"),
+        inArray(taskMessageTable.role, ["assistant", "tool"]),
       ),
     )
     .orderBy(taskMessageTable.seq);
 
   const calls = new Map<
     string,
-    { bot: string; texts: string[]; then: string | null }
+    { bot: string; texts: string[]; then: string | null; exchanges: string[] }
   >();
+  const questions = new Map<string, string>();
   for (const row of rows) {
     if (!row.parent) continue;
     const call = calls.get(row.parent) ?? {
       bot: row.bot ?? "",
       texts: [],
       then: null,
+      exchanges: [],
     };
     const content = row.content as AssistantContent;
     const parts =
@@ -371,6 +374,21 @@ export async function listBorrowedTails(
       } else if (part.type === "tool-call") {
         call.then =
           `${part.toolName} ${toolLine(part.toolName, part.input)}`.trim();
+        if (part.toolName === TOOL_NAMES.ask_back)
+          questions.set(
+            part.toolCallId,
+            String((part.input as { question?: string }).question ?? ""),
+          );
+      } else if (
+        part.type === "tool-result" &&
+        part.toolName === TOOL_NAMES.ask_back
+      ) {
+        const answer = resultParts(part.output, Number.POSITIVE_INFINITY)
+          .flatMap((part) => (part.type === "text" ? [part.text] : []))
+          .join("\n");
+        call.exchanges.push(
+          `They asked you: ${questions.get(part.toolCallId) ?? ""}\nYou answered: ${answer}`,
+        );
       }
     }
     calls.set(row.parent, call);
@@ -380,6 +398,7 @@ export async function listBorrowedTails(
   for (const [id, call] of calls) {
     const tail = [
       ...call.texts.slice(-TAIL.texts).map((text) => clip(text, TAIL.chars)),
+      ...call.exchanges.map((text) => clip(text, TAIL.chars)),
       call.then ? `Then: ${call.then}` : "",
     ]
       .filter(Boolean)
@@ -541,6 +560,63 @@ export async function listThread(taskId: string): Promise<ModelMessage[]> {
   );
 }
 
+/** A participant keeps its own work across every request, including requests from different bots. */
+export async function listBotThread(taskId: string, bot: string) {
+  const rows = await database
+    .select()
+    .from(taskMessageTable)
+    .where(
+      and(
+        eq(taskMessageTable.taskId, taskId),
+        isNotNull(taskMessageTable.parent),
+        eq(sql`lower(${taskMessageTable.bot})`, bot.toLowerCase()),
+      ),
+    )
+    .orderBy(taskMessageTable.seq);
+  // Older runs store their opening only in the caller's tool arguments.
+  const requests = await database
+    .select({ content: taskMessageTable.content, bot: taskMessageTable.bot })
+    .from(taskMessageTable)
+    .where(
+      and(
+        eq(taskMessageTable.taskId, taskId),
+        eq(taskMessageTable.role, "assistant"),
+      ),
+    )
+    .orderBy(taskMessageTable.seq);
+  const openings = new Map<string, ModelMessage>();
+  for (const row of requests) {
+    if (!Array.isArray(row.content)) continue;
+    for (const part of row.content) {
+      if (part.type !== "tool-call" || part.toolName !== TOOL_NAMES.ask_bot)
+        continue;
+      const input = part.input as { request?: string; context?: string };
+      openings.set(part.toolCallId, {
+        role: "user",
+        content: `${row.bot} → ${bot}:\n\n${input.request ?? ""}\n\n${input.context ?? ""}`,
+      });
+    }
+  }
+  const history: { message: ModelMessage; compact: boolean }[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    if (row.parent && !seen.has(row.parent)) {
+      seen.add(row.parent);
+      if (row.role !== "user" || row.compact) {
+        const opening = openings.get(row.parent);
+        if (opening) history.push({ message: opening, compact: false });
+      }
+    }
+    history.push({
+      message: { role: row.role, content: row.content } as ModelMessage,
+      compact: row.compact,
+    });
+  }
+  const from = history.findLastIndex((row) => row.compact);
+  const kept = from > 0 ? [history[0], ...history.slice(from)] : history;
+  return kept.map((row) => row.message);
+}
+
 /** One row in the screen's shape; `pending` folds into `ask`. */
 function viewOf(row: TaskRow, lines: TaskLine[]): Task {
   // contextTokens and contextBudget pass through in `rest`
@@ -576,10 +652,33 @@ async function withLines(rows: TaskRow[]): Promise<Task[]> {
 
   // ask_back lines name no addressee; the task's own bot is the addressee
   const owners = new Map(rows.map((row) => [row.id, row.bot]));
+  const askers = new Map<string, string>();
+  for (const message of messages) {
+    if (message.role !== "assistant" || !Array.isArray(message.content))
+      continue;
+    for (const part of message.content) {
+      if (
+        part.type === "tool-call" &&
+        part.toolName === TOOL_NAMES.ask_bot &&
+        message.bot
+      ) {
+        askers.set(`${message.taskId}:${part.toolCallId}`, message.bot);
+      }
+    }
+  }
   const byTask = new Map<string, TaskLine[]>();
   for (const message of messages) {
     const list = byTask.get(message.taskId) ?? [];
-    list.push(...linesOf(message, owners.get(message.taskId) ?? ""));
+    list.push(
+      ...linesOf(
+        message,
+        (message.parent
+          ? askers.get(`${message.taskId}:${message.parent}`)
+          : null) ??
+          owners.get(message.taskId) ??
+          "",
+      ),
+    );
     byTask.set(message.taskId, list);
   }
   return rows.map((row) => viewOf(row, byTask.get(row.id) ?? []));
@@ -688,6 +787,13 @@ export async function readToolResult(
   return null;
 }
 
+/** Said to a resumed run after why it stopped. The screen shows only the why (linesOf). */
+const IN_FLIGHT =
+  "Anything that was under way — a command, a page loading, a download — may not have finished: check before relying on it, then carry on.";
+
+/** The thread line a stop the app made leaves (bot.runner parkTask). */
+export const stopNote = (why: string) => `${why} ${IN_FLIGHT}`;
+
 type StoredMessage = typeof taskMessageTable.$inferSelect;
 
 /**
@@ -707,14 +813,25 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
   const content = message.content;
 
   if (message.role === "user") {
-    if (message.seq === 0) return [];
+    // Participant requests already appear as the caller's ask_bot line.
+    if (
+      message.seq === 0 ||
+      (message.parent && !message.compact && !message.note)
+    )
+      return [];
     const text = typeof content === "string" ? content : textOf(content);
     if (!text) return [];
-    // The app's own line — a compaction marker, or why a run stopped — never
-    // the user's words. `compact` is read too: rows written before `note` was.
-    if (message.note || message.compact)
-      return [{ ...base, id: id(0), kind: "note", text }];
-    return [{ ...base, id: id(0), kind: "user", text }];
+    // The app's own lines, never the user's words. `compact` alone marks a
+    // compaction: rows written before `note` existed carry only that.
+    if (message.compact) return [{ ...base, id: id(0), kind: "note", text }];
+    if (message.note) {
+      const why = text.endsWith(IN_FLIGHT)
+        ? text.slice(0, -IN_FLIGHT.length).trimEnd()
+        : text;
+      return [{ ...base, id: id(0), kind: "stop", text: why }];
+    }
+    // Tagged with who said it for the bot (bot.schema tagSpeaker); the screen draws the words
+    return [{ ...base, id: id(0), kind: "user", text: untagSpeaker(text) }];
   }
 
   if (message.role === "assistant") {
@@ -817,7 +934,12 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
         const text = resultParts(part.output, RESULT_LINES)
           .flatMap((result) => (result.type === "text" ? [result.text] : []))
           .join("\n");
-        lines.push({ ...base, id: id(index), kind: "user", text });
+        lines.push({
+          ...base,
+          id: id(index),
+          kind: "user",
+          text: untagSpeaker(text),
+        });
       } else if (
         part.toolName === TOOL_NAMES.ask_bot ||
         part.toolName === TOOL_NAMES.ask_back