thursday-agent 0.1.2 → 0.3.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,6 +22,7 @@ import {
   TASK_HISTORY_PAGE,
   type Task,
   type TaskLine,
+  type TaskPending,
   type TaskStatus,
   type TokenUsage,
 } from "./bot.schema";
@@ -29,7 +41,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 +57,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 +67,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 +77,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 +99,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 +113,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 +166,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 +179,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(),
@@ -226,9 +237,11 @@ export async function deleteFinishedTasks() {
   const removed = await database
     .delete(taskTable)
     .where(inArray(taskTable.status, ["done", "failed"]))
-    .returning({ id: taskTable.id });
+    // The label comes back too: a job's working folder is named for it and goes
+    // with the row (bot.runner removeFinishedTasks).
+    .returning({ id: taskTable.id, label: taskTable.label });
   if (removed.length) changed();
-  return removed.length;
+  return removed;
 }
 
 /** Every job, newest first. The caller stops each one before deleting it (bot.runner removeTask). */
@@ -249,6 +262,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.
@@ -275,6 +459,8 @@ export type TaskMessageInput = {
   content: ModelMessage["content"];
   /** Compaction summary row; `listThread` re-reads from here. */
   compact?: boolean;
+  /** Drawn as the app's own line, not as something a person or a bot said. */
+  note?: boolean;
 };
 
 /**
@@ -288,13 +474,20 @@ export async function upsertMessage(
 ) {
   await database
     .insert(taskMessageTable)
-    .values({ taskId, seq, ...message, compact: message.compact ?? false })
+    .values({
+      taskId,
+      seq,
+      ...message,
+      compact: message.compact ?? false,
+      note: message.note ?? false,
+    })
     .onConflictDoUpdate({
       target: [taskMessageTable.taskId, taskMessageTable.seq],
       set: {
         role: message.role,
         content: message.content,
         compact: message.compact ?? false,
+        note: message.note ?? false,
       },
     });
   changed();
@@ -326,7 +519,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
@@ -341,9 +535,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`. */
@@ -354,7 +549,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,
@@ -417,8 +616,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.
  */
@@ -512,8 +710,10 @@ function linesOf(message: StoredMessage, owner: string): TaskLine[] {
     if (message.seq === 0) return [];
     const text = typeof content === "string" ? content : textOf(content);
     if (!text) return [];
-    // Compaction summary row: a marker, not the user's words (bot.run compact)
-    if (message.compact) return [{ ...base, id: id(0), kind: "note", text }];
+    // 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 }];
   }
 
@@ -547,8 +747,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 });
@@ -607,8 +807,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;
       }

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
@@ -76,9 +82,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. */
@@ -219,9 +225,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 +252,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,
@@ -266,7 +272,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. */
@@ -424,3 +430,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]);
+}