thursday-agent 0.2.0 → 0.4.0

package/features/bot/task.query.ts

@@ -1,9 +1,20 @@
 import type { AssistantContent, ModelMessage, ToolContent } from "ai";
-import { and, desc, eq, inArray, isNull, lt, max, sql } from "drizzle-orm";
+import {
+  and,
+  desc,
+  eq,
+  inArray,
+  isNotNull,
+  isNull,
+  lt,
+  max,
+  sql,
+} from "drizzle-orm";
 import { appEvents } from "@/app/api/events/app-event.server";
+import { INBOX_FINISHED } from "@/config";
 import { database } from "@/database/db";
 import { taskMessageTable, taskTable } from "@/database/tables";
-import { reportAccepted } from "@/features/ai/tools/bot.tool";
+import { answerAccepted, isAnswerCall } from "@/features/ai/tools/bot.tool";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { clip } from "@/lib/utils";
 import {
@@ -11,8 +22,10 @@ import {
   TASK_HISTORY_PAGE,
   type Task,
   type TaskLine,
+  type TaskPending,
   type TaskStatus,
   type TokenUsage,
+  untagSpeaker,
 } from "./bot.schema";
 
 // Tasks and their threads. Bots themselves (roster, pinned tools) are bot.query.
@@ -29,7 +42,7 @@ const taskView = {
   status: taskTable.status,
   outcome: taskTable.outcome,
   pending: taskTable.pending,
-  reported: taskTable.reported,
+  seen: taskTable.seen,
   inputTokens: taskTable.inputTokens,
   outputTokens: taskTable.outputTokens,
   contextTokens: taskTable.contextTokens,
@@ -45,8 +58,8 @@ type TaskRow = {
   request: string;
   status: TaskStatus;
   outcome: string | null;
-  pending: { toolCallId: string | null; options: string[] } | null;
-  reported: boolean;
+  pending: TaskPending | null;
+  seen: boolean;
   inputTokens: number;
   outputTokens: number;
   contextTokens: number;
@@ -55,12 +68,9 @@ type TaskRow = {
   updatedAt: Date;
 };
 
-/** How many finished tasks the inbox keeps; the rest live in Settings > Tasks. */
-const INBOX_RECENT_FINISHED = 3;
-
 /**
  * One row plus the thread's first message. `request` is what the screen shows;
- * `opening` is what the model reads (request plus recent call turns). The screen
+ * `opening` is what the model reads (who is who, the job, the call it came from). The screen
  * skips seq 0 and shows `request` instead (linesOf).
  */
 export async function insertTask(input: {
@@ -68,7 +78,7 @@ export async function insertTask(input: {
   label: string;
   request: string;
   callId?: string | null;
-  opening: string;
+  opening: Extract<ModelMessage, { role: "user" }>["content"];
 }) {
   const { opening, ...row } = input;
   const [task] = await database
@@ -90,9 +100,11 @@ export async function updateTask(
   patch: Partial<{
     status: TaskStatus;
     outcome: string | null;
-    pending: { toolCallId: string | null; options: string[] } | null;
-    reported: boolean;
+    pending: TaskPending | null;
+    seen: boolean;
     endedAt: Date | null;
+    /** Where the job compacts from now on; also written at every step (addTaskUsage). */
+    contextBudget: number;
   }>,
 ) {
   await database
@@ -102,12 +114,12 @@ export async function updateTask(
   changed();
 }
 
-/** Bypasses `updateTask` on purpose: reporting is not movement and must not reorder the inbox by updatedAt. */
-export async function markReported(ids: string[]) {
+/** Bypasses `updateTask` on purpose: being seen is not movement and must not reorder the inbox by updatedAt. */
+export async function markSeen(ids: string[]) {
   if (ids.length === 0) return;
   await database
     .update(taskTable)
-    .set({ reported: true })
+    .set({ seen: true })
     .where(inArray(taskTable.id, ids));
   changed();
 }
@@ -155,7 +167,7 @@ export async function findTask(id: string) {
   return task ?? null;
 }
 
-/** Inbox: everything running or waiting plus the most recently finished few, newest first. `reported` is not a filter here. */
+/** Inbox: everything running or waiting plus the latest INBOX_FINISHED endings, newest first. `seen` is not a filter here. */
 export async function listInboxTasks(): Promise<Task[]> {
   const [open, finished] = await Promise.all([
     database
@@ -168,7 +180,7 @@ export async function listInboxTasks(): Promise<Task[]> {
       .from(taskTable)
       .where(inArray(taskTable.status, ["done", "failed"]))
       .orderBy(desc(taskTable.updatedAt))
-      .limit(INBOX_RECENT_FINISHED),
+      .limit(INBOX_FINISHED),
   ]);
   const rows = [...open, ...finished].sort(
     (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime(),
@@ -251,6 +263,177 @@ export async function listRunningTaskIds() {
   return rows.map((row) => row.id);
 }
 
+/** Every job with what names its folder and whether it still keeps it (bot.runner sweepJobFiles). */
+export async function listTaskFolders() {
+  return await database
+    .select({
+      id: taskTable.id,
+      label: taskTable.label,
+      status: taskTable.status,
+      endedAt: taskTable.endedAt,
+      updatedAt: taskTable.updatedAt,
+    })
+    .from(taskTable);
+}
+
+/** Jobs the app parked to pick back up by itself (bot.runner parkTask), and when each may go. */
+export async function listAutoStoppedTasks() {
+  const rows = await database
+    .select({ id: taskTable.id, pending: taskTable.pending })
+    .from(taskTable)
+    .where(eq(taskTable.status, "waiting"));
+  return rows.flatMap((row) =>
+    row.pending?.auto
+      ? [{ id: row.id, retryAt: row.pending.retryAt ?? 0 }]
+      : [],
+  );
+}
+
+/**
+ * How many times the app has stopped this job since a person last said anything
+ * to it: the notes it left in the thread — a break, a park — back to the last row
+ * a person wrote: the opening, an answer, a word to a running job. Read off the
+ * rows rather than kept as a count, so it cannot drift from what the thread shows.
+ */
+export async function countStopsSinceSpoken(taskId: string): Promise<number> {
+  const rows = await database
+    .select({
+      role: taskMessageTable.role,
+      bot: taskMessageTable.bot,
+      note: taskMessageTable.note,
+      compact: taskMessageTable.compact,
+    })
+    .from(taskMessageTable)
+    .where(
+      and(eq(taskMessageTable.taskId, taskId), isNull(taskMessageTable.parent)),
+    )
+    .orderBy(desc(taskMessageTable.seq));
+  let stops = 0;
+  for (const row of rows) {
+    if (row.note) {
+      if (!row.compact) stops += 1;
+      continue;
+    }
+    // A person: the opening and every answer are written with no bot, and a
+    // word to a running job is a user row in the bot's name
+    if (row.bot === null || row.role === "user") break;
+  }
+  return stops;
+}
+
+/** How much of a cut-off borrowed bot's prose a resume carries: its last few paragraphs. */
+const TAIL = { texts: 3, chars: 600 };
+
+/**
+ * What each borrowed bot had written when its `ask_bot` call stopped, by that
+ * call's id: its last few paragraphs, and the tool it reached for after them. A
+ * resumed run reads it where the call's result never arrived (bot.run
+ * resumeThread), so a part cut off half-way is carried on, not asked for afresh.
+ */
+export async function listBorrowedTails(
+  taskId: string,
+): Promise<Map<string, { bot: string; tail: string }>> {
+  const rows = await database
+    .select({
+      parent: taskMessageTable.parent,
+      bot: taskMessageTable.bot,
+      content: taskMessageTable.content,
+    })
+    .from(taskMessageTable)
+    .where(
+      and(
+        eq(taskMessageTable.taskId, taskId),
+        isNotNull(taskMessageTable.parent),
+        eq(taskMessageTable.role, "assistant"),
+      ),
+    )
+    .orderBy(taskMessageTable.seq);
+
+  const calls = new Map<
+    string,
+    { bot: string; texts: string[]; then: string | null }
+  >();
+  for (const row of rows) {
+    if (!row.parent) continue;
+    const call = calls.get(row.parent) ?? {
+      bot: row.bot ?? "",
+      texts: [],
+      then: null,
+    };
+    const content = row.content as AssistantContent;
+    const parts =
+      typeof content === "string"
+        ? [{ type: "text" as const, text: content }]
+        : content;
+    for (const part of parts) {
+      if (part.type === "text" && part.text.trim()) {
+        call.texts.push(part.text.trim());
+        call.then = null;
+      } else if (part.type === "tool-call") {
+        call.then =
+          `${part.toolName} ${toolLine(part.toolName, part.input)}`.trim();
+      }
+    }
+    calls.set(row.parent, call);
+  }
+
+  const tails = new Map<string, { bot: string; tail: string }>();
+  for (const [id, call] of calls) {
+    const tail = [
+      ...call.texts.slice(-TAIL.texts).map((text) => clip(text, TAIL.chars)),
+      call.then ? `Then: ${call.then}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n\n");
+    if (tail) tails.set(id, { bot: call.bot, tail });
+  }
+  return tails;
+}
+
+/**
+ * Paths a list of message contents gave `write_file`, oldest first and each once; a
+ * path written again moves to the end. A refused write is here too, so whoever shows
+ * them checks the disk (workspace.ts filesOnDisk).
+ */
+export function writtenPathsIn(contents: unknown[]): string[] {
+  const paths = new Set<string>();
+  for (const content of contents) {
+    if (!Array.isArray(content)) continue;
+    for (const part of content as {
+      type?: unknown;
+      toolName?: unknown;
+      input?: unknown;
+    }[]) {
+      if (
+        part.type !== "tool-call" ||
+        part.toolName !== TOOL_NAMES.write_file
+      ) {
+        continue;
+      }
+      const path = (part.input as { path?: unknown } | null)?.path;
+      if (typeof path !== "string" || !path.trim()) continue;
+      paths.delete(path.trim());
+      paths.add(path.trim());
+    }
+  }
+  return [...paths];
+}
+
+/** Every path this job gave `write_file`: its own bot and each bot it borrowed (writtenPathsIn). */
+export async function listWrittenPaths(taskId: string): Promise<string[]> {
+  const rows = await database
+    .select({ content: taskMessageTable.content })
+    .from(taskMessageTable)
+    .where(
+      and(
+        eq(taskMessageTable.taskId, taskId),
+        eq(taskMessageTable.role, "assistant"),
+      ),
+    )
+    .orderBy(taskMessageTable.seq);
+  return writtenPathsIn(rows.map((row) => row.content));
+}
+
 /**
  * Finds a task by id or by exact label (case-insensitive). No looser matching:
  * a miss returns null and the caller lists recent tasks instead.
@@ -337,7 +520,8 @@ export async function lastSeq(taskId: string): Promise<number> {
 /**
  * The task's own thread as the model sees it: parent-less messages in order.
  * What a borrowed bot said inside an `ask_bot` call is not here; its result is.
- * Starts at the last compact row when there is one.
+ * After a compaction it is the opening, then the last compact row on: a summary
+ * replaces what came after the job and the call, never the job and the call.
  */
 export async function listThread(taskId: string): Promise<ModelMessage[]> {
   const rows = await database
@@ -352,9 +536,10 @@ export async function listThread(taskId: string): Promise<ModelMessage[]> {
     )
     .orderBy(taskMessageTable.seq);
   const from = rows.findLastIndex((row) => row.compact);
-  return rows
-    .slice(Math.max(from, 0))
-    .map((row) => ({ role: row.role, content: row.content }) as ModelMessage);
+  const kept = from > 0 ? [rows[0], ...rows.slice(from)] : rows;
+  return kept.map(
+    (row) => ({ role: row.role, content: row.content }) as ModelMessage,
+  );
 }
 
 /** One row in the screen's shape; `pending` folds into `ask`. */
@@ -365,7 +550,11 @@ function viewOf(row: TaskRow, lines: TaskLine[]): Task {
     ...rest,
     ask:
       row.status === "waiting"
-        ? { question: row.outcome ?? "", options: pending?.options ?? [] }
+        ? {
+            question: row.outcome ?? "",
+            options: pending?.options ?? [],
+            auto: pending?.auto === true,
+          }
         : null,
     tokens: { input: inputTokens, output: outputTokens },
     lines,
@@ -428,8 +617,7 @@ function labelOf(args: Record<string, unknown>): string | null {
 }
 
 /**
- * One tool call as one line. Shared by the screen and by the resumed bot's
- * re-read history (bot.run condenseThread). No per-tool summary table: the
+ * One tool call as one line, for the screen. No per-tool summary table: the
  * label is model-written (bash `description`), other tools use the first
  * telling argument, else the argument shape.
  */
@@ -501,6 +689,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;
 
 /**
@@ -523,11 +718,17 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
     if (message.seq === 0) 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") {
@@ -560,8 +761,8 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
           question: String(args.question ?? ""),
           options: optionsOf(args.options),
         });
-      } else if (part.toolName === TOOL_NAMES.report) {
-        // The report is a tool call but draws as text: it is the last thing said
+      } else if (isAnswerCall(part.toolName)) {
+        // The answer is a tool call but draws as text: it is the last thing said
         // in the thread, and taskFromRow promotes it to the result line
         const text = String(args.result ?? "").trim();
         if (text) lines.push({ ...base, id: id(index), kind: "text", text });
@@ -620,8 +821,8 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
     const lines: TaskLine[] = [];
     (message.content as ToolContent).forEach((part, index) => {
       if (part.type !== "tool-result") return;
-      if (part.toolName === TOOL_NAMES.report && reportAccepted(part.output)) {
-        // An accepted report's result is only a confirmation; the report itself
+      if (isAnswerCall(part.toolName) && answerAccepted(part.output)) {
+        // An accepted answer's result is only a confirmation; the answer itself
         // was drawn from the call. A rejected one is drawn: it explains the next step
         return;
       }
@@ -630,7 +831,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

package/features/bot/task.store.ts

@@ -1,6 +1,9 @@
 "use client";
 
-import { useSyncExternalStore } from "react";
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import { queryKey } from "@/app/api/query-key";
+import { toast } from "@/components/ui/toast";
+import { markSeenAction } from "@/features/bot/bot.action";
 import type {
   Bot,
   BotIcon,
@@ -8,7 +11,10 @@ import type {
   Task,
   TokenUsage,
 } from "@/features/bot/bot.schema";
-import type { DateLike } from "@/lib/date-like";
+import { type DateLike, toDate } from "@/lib/date-like";
+import { unwrapResult } from "@/lib/protocol/result";
+import { revalidate } from "@/lib/protocol/use-server-route";
+import { errorToString } from "@/lib/utils";
 
 /**
  * Client mirror of tasks, keyed by task rather than as one message stream so
@@ -18,7 +24,11 @@ import type { DateLike } from "@/lib/date-like";
 
 export type BotRef = { name: string; icon?: BotIcon | null };
 
-/** `note` is a marker, not speech: a compaction summary (bot.run compact). Draw as a divider. */
+/**
+ * `note` and `stop` are the app's markers, not speech. `note` is a compaction
+ * summary (bot.run compact), drawn as a divider; `stop` is where the app stopped
+ * the run (bot.runner parkTask), drawn muted in the bot's turn.
+ */
 export type ChatterKind =
   | "say"
   | "ask"
@@ -26,7 +36,8 @@ export type ChatterKind =
   | "user"
   | "result"
   | "error"
-  | "note";
+  | "note"
+  | "stop";
 
 /** One tool call. `name` picks the renderer (components/bot-tool); `results` arrive after the call. */
 export type ToolUse = {
@@ -57,6 +68,8 @@ export type Chatter = {
   tool?: ToolUse;
   /** Options attached to a question; only on the line where the bot stopped to ask. */
   options?: string[];
+  /** When it was written; only for kind `stop`, whose repeats fold into one line. */
+  at?: DateLike;
 };
 
 /** `waiting`: the bot stopped to ask the user something. */
@@ -76,9 +89,9 @@ export type TaskView = {
   /** Text it came back with; only after it returned. */
   outcome: string | null;
   /** What it is asking while `waiting`. */
-  ask: { question: string; options: string[] } | null;
-  /** Whether it has been relayed to Thursday; otherwise the room shows a dot. */
-  relayed: boolean;
+  ask: Task["ask"];
+  /** Whether the user has had the ending (Task `seen`). */
+  seen: boolean;
   /** Burned so far. */
   tokens: TokenUsage;
   /** Context read on the last step and the compaction threshold; the header meter is their ratio. Both 0 means no step ran yet. */
@@ -153,6 +166,16 @@ export function taskFromRow(row: Task, bots?: Bot[]): TaskView {
       case "note":
         lines.push({ id: line.id, bot, to, text: line.text, kind: "note" });
         break;
+      case "stop":
+        lines.push({
+          id: line.id,
+          bot,
+          to,
+          text: line.text,
+          kind: "stop",
+          at: line.at,
+        });
+        break;
       case "tool":
         openLines.set(line.callId, lines.length);
         lines.push({
@@ -219,9 +242,9 @@ export function taskFromRow(row: Task, bots?: Bot[]): TaskView {
     }
   }
 
-  // The ending lives on the row, not in the thread: the report is the last text
+  // The ending lives on the row, not in the thread: the answer is the last text
   // said, failure exists only here. `waiting` is treated like done: a job that
-  // stopped for budget reported first, so that line is a result.
+  // the app stopped answered first, so that line is a result.
   if (row.status === "failed" && row.outcome) {
     lines.push({
       id: `${row.id}-end`,
@@ -246,7 +269,7 @@ export function taskFromRow(row: Task, bots?: Bot[]): TaskView {
     status: row.status === "running" ? "working" : row.status,
     outcome: row.outcome,
     ask: row.ask,
-    relayed: row.reported,
+    seen: row.seen,
     tokens: row.tokens,
     contextTokens: row.contextTokens,
     contextBudget: row.contextBudget,
@@ -258,7 +281,8 @@ export function taskFromRow(row: Task, bots?: Bot[]): TaskView {
 export function lastSaid(task: TaskView): Chatter | null {
   for (let at = task.lines.length - 1; at >= 0; at--) {
     const line = task.lines[at];
-    if (line.kind !== "user" && line.kind !== "note") return line;
+    if (line.kind !== "user" && line.kind !== "note" && line.kind !== "stop")
+      return line;
   }
   return null;
 }
@@ -266,7 +290,7 @@ export function lastSaid(task: TaskView): Chatter | null {
 /**
  * What the screen did to a task. Announced so the call can hear it: a poll
  * cannot tell a screen answer from a voice answer, and a cancel is never relayed
- * (bot.runner cancelTask marks it reported).
+ * (bot.runner cancelTask marks it seen).
  */
 export type ScreenAct =
   /** Answered a waiting task, interjected into a running one, or continued a finished one. */
@@ -406,7 +430,8 @@ export function latestPerBot(list: TaskView[]): BotLine[] {
       byBot.set(task.bot.name, { bot: task.bot, task, line: null, open: 0 });
     }
     for (const line of task.lines) {
-      if (line.kind === "user" || line.kind === "note") continue;
+      if (line.kind === "user" || line.kind === "note" || line.kind === "stop")
+        continue;
       byBot.set(line.bot.name, {
         bot: line.bot,
         task,
@@ -424,3 +449,41 @@ export function latestPerBot(list: TaskView[]): BotLine[] {
 
   return [...byBot.values()];
 }
+
+/**
+ * Opening a job's detail is reading its ending: the thread in the room, a row
+ * expanded in Settings › Tasks. That is what clears its dot — a list scrolled
+ * past or a line heard on a call is not. Keyed by `updatedAt` as well, because a
+ * follow-up ends a job a second time and that ending is new again.
+ */
+export function useSeenOnDetail(
+  task:
+    | { id: string; status: string; seen: boolean; updatedAt: DateLike }
+    | null
+    | undefined,
+) {
+  const sent = useRef(new Set<string>());
+  const id = task?.id ?? null;
+  const key = task ? `${task.id}@${toDate(task.updatedAt).getTime()}` : null;
+  const owed =
+    !!task &&
+    (task.status === "done" || task.status === "failed") &&
+    !task.seen;
+
+  useEffect(() => {
+    if (!id || !key || !owed || sent.current.has(key)) return;
+    sent.current.add(key);
+    void markSeenAction([id])
+      .then(unwrapResult)
+      .then(() => revalidate(queryKey.tasks))
+      .catch((cause) => {
+        // Released, so opening it again tries again
+        sent.current.delete(key);
+        toast.add({
+          type: "error",
+          title: "Could not mark the task as read",
+          description: errorToString(cause),
+        });
+      });
+  }, [id, key, owed]);
+}