thursday-agent 0.1.2 → 0.3.0

package/features/thursday/thursday.query.ts

@@ -7,12 +7,14 @@ import {
   isNotNull,
   isNull,
   lt,
+  sql,
 } from "drizzle-orm";
+import { CALL_HISTORY_PAGE } from "@/config";
 import { database } from "@/database/db";
 import { callMessageTable, callTable } from "@/database/tables";
+import { listCallJobs } from "@/features/bot/task.query";
 import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
-  CALL_HISTORY_PAGE,
   type CallRecord,
   type CallTurn,
   isSkillsOn,
@@ -139,6 +141,52 @@ export async function listCallTurns(
     .map((row) => ({ role: row.role as "user" | "assistant", text: row.text }));
 }
 
+/**
+ * One page of a call, every turn in order, tool turns included; null when the
+ * call is gone. Tool turns keep their name and nothing else is read by the
+ * caller (ai/tools/memory.tool), but the row carries it all.
+ */
+export async function readCallConversation(
+  callId: string,
+  page: number,
+  size: number,
+): Promise<{
+  startedAt: Date;
+  total: number;
+  turns: {
+    role: "user" | "assistant" | "tool";
+    tool: string | null;
+    text: string;
+  }[];
+} | null> {
+  const [call] = await database
+    .select({ startedAt: callTable.startedAt })
+    .from(callTable)
+    .where(eq(callTable.id, callId));
+  if (!call) return null;
+
+  const [counted] = await database
+    .select({ total: sql<number>`count(*)` })
+    .from(callMessageTable)
+    .where(eq(callMessageTable.callId, callId));
+  const turns = await database
+    .select({
+      role: callMessageTable.role,
+      tool: callMessageTable.tool,
+      text: callMessageTable.text,
+    })
+    .from(callMessageTable)
+    .where(eq(callMessageTable.callId, callId))
+    .orderBy(asc(callMessageTable.seq))
+    .limit(size)
+    .offset((page - 1) * size);
+  return {
+    startedAt: call.startedAt,
+    total: Number(counted?.total ?? 0),
+    turns,
+  };
+}
+
 /**
  * Whether any call is open, not whether a given job's call is. A tab that
  * vanished leaves its row open, so boot runs `sweepCalls` first.
@@ -231,81 +279,24 @@ export async function listCallHistory(options: {
     else turns.set(callId, [turn]);
   }
 
+  // A job belongs to the call that opened it, and this is how the log still says
+  // what became of it once the call is over.
+  const jobs = await listCallJobs(calls.map((call) => call.id));
+
   return calls.map((call) => ({
     ...call,
     turns: turns.get(call.id) ?? [],
+    jobs: jobs
+      .filter((job) => job.callId === call.id)
+      .map((job) => ({
+        id: job.id,
+        label: job.label,
+        status: job.status,
+        outcome: job.outcome,
+      })),
   }));
 }
 
-// What reading calls back needs (features/memory/memory.tidy): the turns owed,
-// and the stamp that says they have been read.
-
-/** One spoken turn owed to a read-back, with the call it came from. */
-export type OwedTurn = {
-  callId: string;
-  startedAt: Date;
-  role: "user" | "assistant";
-  text: string;
-};
-
-/**
- * Every spoken turn of ended calls not read back yet, oldest first. Tool turns
- * are left out: they carry arguments, not anything said. A call with no user
- * turn still counts nothing towards a read but is stamped with the rest.
- */
-export async function listOwedTurns(): Promise<OwedTurn[]> {
-  const rows = await database
-    .select({
-      callId: callTable.id,
-      startedAt: callTable.startedAt,
-      role: callMessageTable.role,
-      text: callMessageTable.text,
-    })
-    .from(callTable)
-    .innerJoin(callMessageTable, eq(callMessageTable.callId, callTable.id))
-    .where(
-      and(
-        isNotNull(callTable.endedAt),
-        isNull(callTable.tidiedAt),
-        inArray(callMessageTable.role, ["user", "assistant"]),
-      ),
-    )
-    .orderBy(asc(callTable.startedAt), asc(callMessageTable.seq));
-
-  return rows.map((row) => ({
-    callId: row.callId,
-    startedAt: row.startedAt,
-    role: row.role as "user" | "assistant",
-    text: row.text,
-  }));
-}
-
-/** Ids of every ended call not read back yet. A read stamps all of them, including the ones it dropped. */
-export async function listUnreadCallIds(): Promise<string[]> {
-  const rows = await database
-    .select({ id: callTable.id })
-    .from(callTable)
-    .where(and(isNotNull(callTable.endedAt), isNull(callTable.tidiedAt)))
-    .orderBy(asc(callTable.startedAt));
-  return rows.map((row) => row.id);
-}
-
-export async function markCallsRead(ids: string[]) {
-  if (!ids.length) return;
-  await database
-    .update(callTable)
-    .set({ tidiedAt: new Date() })
-    .where(inArray(callTable.id, ids));
-}
-
-/** Stamps every ended call as read, so switching the setting on starts from now. */
-export async function markEveryCallRead() {
-  await database
-    .update(callTable)
-    .set({ tidiedAt: new Date() })
-    .where(and(isNotNull(callTable.endedAt), isNull(callTable.tidiedAt)));
-}
-
 /**
  * Every call that has ended, and its turns (cascade). A call still on the line
  * stays: its tab is still writing turns against the row (see `deleteCall`).

package/features/thursday/thursday.schema.ts

@@ -1,9 +1,10 @@
 import z from "zod";
+import { ASCII_FACE } from "@/config";
 import {
   type SpeachModelProviderId,
   speachModelRefSchema,
 } from "@/features/ai/model.schema";
-import { botIconSchema } from "@/features/bot/bot.schema";
+import { botIconSchema, type TaskStatus } from "@/features/bot/bot.schema";
 import { ASCII_CHARSETS, FACE_KINDS } from "@/features/thursday/face.const";
 import type { DateLike } from "@/lib/date-like";
 import { COMMON_VALIDATE } from "@/lib/limits";
@@ -48,10 +49,18 @@ export type CallHandshake = {
  */
 export const ThursdayFaceSchema = botIconSchema.extend({
   kind: z.enum(FACE_KINDS).default("ascii"),
-  charset: z.enum(ASCII_CHARSETS).default("ascii"),
+  charset: z.enum(ASCII_CHARSETS).default(ASCII_FACE.charset),
   /** Glyph size in px. */
-  fontSize: z.number().min(4).max(16).default(8),
-  density: z.number().min(0.6).max(2).default(1.4),
+  fontSize: z
+    .number()
+    .min(ASCII_FACE.fontSize.min)
+    .max(ASCII_FACE.fontSize.max)
+    .default(ASCII_FACE.fontSize.default),
+  density: z
+    .number()
+    .min(ASCII_FACE.density.min)
+    .max(ASCII_FACE.density.max)
+    .default(ASCII_FACE.density.default),
 });
 
 export type ThursdayFace = z.infer<typeof ThursdayFaceSchema>;
@@ -177,7 +186,11 @@ export type CallRecord = {
   /** null when the hang-up was never recorded. */
   endedAt: DateLike | null;
   turns: (CallTurn & { at: DateLike })[];
+  /** Jobs this call opened, as they stand now; the log draws each under the line that opened it. */
+  jobs: {
+    id: string;
+    label: string;
+    status: TaskStatus;
+    outcome: string | null;
+  }[];
 };
-
-/** History page size in calls, not rows; each call carries every turn. */
-export const CALL_HISTORY_PAGE = 10;

package/features/thursday/tool-line.ts

@@ -13,8 +13,50 @@ const LINES: Record<string, string> = {
   [TOOL_NAMES.end_call]: "Ending the call",
 };
 
+/**
+ * How much of a fact the line carries. What is being written is the one thing
+ * on this screen the user cannot check afterwards without opening the note, so
+ * it is said as it happens — but the row is one line that also carries the
+ * path and the tool's name, and a fact cut mid-word reads as a bug rather than
+ * a quotation.
+ */
+const FACT_MAX = 28;
+
+function snippet(text: string): string {
+  const said = text.trim().replace(/\s+/g, " ");
+  if (said.length <= FACT_MAX) return said;
+  const cut = said.slice(0, FACT_MAX);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > FACT_MAX / 2 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+
+/** The first fact of a `memory_remember` call, while the arguments are whole enough to read. */
+function firstFact(
+  args: Record<string, unknown>,
+): { text: string; more: number } | null {
+  if (!Array.isArray(args.facts)) return null;
+  const texts = args.facts
+    .map((fact) =>
+      fact &&
+      typeof fact === "object" &&
+      typeof (fact as { text?: unknown }).text === "string"
+        ? (fact as { text: string }).text.trim()
+        : "",
+    )
+    .filter(Boolean);
+  return texts.length ? { text: texts[0], more: texts.length - 1 } : null;
+}
+
 /** Lines that need the arguments; arguments may still be streaming in. */
 function fromArgs(name: string, args: Record<string, unknown>): string | null {
+  if (name === TOOL_NAMES.memory_remember) {
+    const path = typeof args.path === "string" ? args.path.trim() : "";
+    const fact = firstFact(args);
+    if (!path) return null;
+    if (!fact) return `Noting that under ${path}`;
+    const more = fact.more > 0 ? ` (+${fact.more})` : "";
+    return `Noting under ${path}: ${snippet(fact.text)}${more}`;
+  }
   if (name === TOOL_NAMES.delegate) {
     const bot = typeof args.bot === "string" ? args.bot.trim() : "";
     return bot ? `Handing this to ${bot}` : "Handing this over";
@@ -35,20 +77,52 @@ function fromServer(name: string): string | null {
   return `Reaching ${name.slice(0, at).replace(/[-_]/g, " ")}`;
 }
 
+/** Arguments as an object, or null while they are still streaming in. */
+function parseArgs(args?: string): Record<string, unknown> | null {
+  if (!args) return null;
+  try {
+    const value: unknown = JSON.parse(args);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value as Record<string, unknown>;
+    }
+  } catch {
+    // Partial or non-JSON arguments: fall back to the name-only line.
+  }
+  return null;
+}
+
 export function toolLine(name: string, args?: string): string | null {
   if (name === TOOL_NAMES.tool_search || name === TOOL_NAMES.tool_call) {
     return "Reaching a connected service";
   }
-  let parsed: Record<string, unknown> | null = null;
-  if (args) {
-    try {
-      const value: unknown = JSON.parse(args);
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        parsed = value as Record<string, unknown>;
-      }
-    } catch {
-      // Partial or non-JSON arguments: fall back to the name-only line.
-    }
-  }
+  const parsed = parseArgs(args);
   return (parsed && fromArgs(name, parsed)) ?? LINES[name] ?? fromServer(name);
 }
+
+/**
+ * The bot a call hands work to, when it names one. The row draws that bot's own
+ * face instead of a glyph: who it went to is a face everywhere else in the app.
+ */
+export function toolBot(name: string, args?: string): string | null {
+  if (name !== TOOL_NAMES.delegate && name !== TOOL_NAMES.ask_bot) return null;
+  const bot = parseArgs(args)?.bot;
+  return typeof bot === "string" && bot.trim() ? bot.trim() : null;
+}
+
+/**
+ * The label a `delegate` call was made under, or null for any other turn. It is
+ * how a job is found again from the line that opened it — in her prompt and in
+ * the call log alike.
+ */
+export function delegatedLabel(
+  tool: string | null | undefined,
+  text: string,
+): string | null {
+  if (tool !== TOOL_NAMES.delegate) return null;
+  try {
+    const said = JSON.parse(text) as { label?: unknown };
+    return typeof said.label === "string" ? said.label : null;
+  } catch {
+    return null;
+  }
+}

package/features/thursday/use-thursday.ts

@@ -5,10 +5,9 @@ import { useAppEvent } from "@/app/api/events/app-event.client";
 import { queryKey } from "@/app/api/query-key";
 import { toast } from "@/components/ui/toast";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import { markReportedAction } from "@/features/bot/bot.action";
 import {
   type Bot,
-  isBudgetAsk,
+  isAppStop,
   TASK_CONTINUE,
   type Task,
 } from "@/features/bot/bot.schema";
@@ -45,7 +44,7 @@ import type {
   LiveStatus,
 } from "./thursday.schema";
 import { thursdaySettings, useThursdayStore } from "./thursday.store";
-import { toolLine } from "./tool-line";
+import { toolBot, toolLine } from "./tool-line";
 
 /**
  * One live call, plus the task inbox the app watches even with no call open.
@@ -103,6 +102,14 @@ const IDLE_GRACE_MS = 15_000;
 /** The countdown shows on screen inside this window. */
 const IDLE_WARN_MS = 15_000;
 
+/**
+ * The user finished a turn and nothing came back — no words, no tool — for this
+ * long. The line is up and the model is not on it, so there is no goodbye to
+ * ask for: the page hangs up. Only armed while an answer is owed, so a quiet
+ * line still ends the slow way (IDLE_HANG_UP_MS).
+ */
+const AGENT_SILENT_MS = 30_000;
+
 const IDLE_LINE =
   "The user has said nothing for a minute. Say a one-line goodbye, then call end_call.";
 
@@ -112,13 +119,9 @@ const IDLE_LINE =
  */
 const RELAY_MIC_MS = 15_000;
 
-/**
- * A line queued for the model. `mark` is the task id to mark reported once the
- * line is actually sent, not when it is queued.
- */
+/** A line queued for the model. */
 type Said = {
   line: string;
-  mark?: string;
   /** Shown on the activity line when the line is sent. */
   show?: ToolRun;
 };
@@ -132,8 +135,10 @@ export type ToolRun = {
   name: string;
   line: string | null;
   done: boolean;
-  /** A relay from a bot (report or question) rather than a tool; `name` is the task label. */
+  /** A relay from a bot (answer or question) rather than a tool; `name` is the task label. */
   kind?: "tool" | "relay";
+  /** The bot this names, when it names one: the row draws its face instead of a glyph. */
+  bot?: string | null;
 };
 
 export function useThursday() {
@@ -162,12 +167,16 @@ export function useThursday() {
     spoke: boolean;
     giveUp: ReturnType<typeof setTimeout> | null;
   }>({ tool: false, reading: false, spoke: false, giveUp: null });
-  /** Last activity time, and whether the goodbye was requested. */
+  /**
+   * Last activity time, whether the goodbye was requested, and when an answer
+   * started being owed (null once she answers or works).
+   */
   const idle = useRef<{
     since: number;
     asked: boolean;
+    owed: number | null;
     grace: ReturnType<typeof setTimeout> | null;
-  }>({ since: 0, asked: false, grace: null });
+  }>({ since: 0, asked: false, owed: null, grace: null });
   const linger = useRef<ReturnType<typeof setTimeout> | null>(null);
   // Every server-run tool in this call starts with this signal, so one abort
   // reaches running browser commands. Delegated tasks are server-owned and outlive the call
@@ -176,14 +185,15 @@ export function useThursday() {
   const callId = useRef<string | null>(null);
   /**
    * Relays sent this call, keyed by relayKey (id + updatedAt): an answered task
-   * comes back with reported=false and may ask again, so the id alone would
-   * silence its second question.
+   * can stop to ask again, so the id alone would silence its second question.
    */
   const relayed = useRef(new Set<string>());
+  /** When this call was placed. An ending from before it is already in her prompt. */
+  const placedAt = useRef(0);
   /**
    * Lines for the model, including ones raised before the line opens. Held
-   * until the session exists so nothing is marked reported unheard; this is
-   * also what lets a call-back queue its line first.
+   * until the session exists, which is also what lets a call-back queue its
+   * line first.
    */
   const outboxRef = useRef<Outbox<Said> | null>(null);
   const outbox = (outboxRef.current ??= createOutbox<Said>());
@@ -206,6 +216,7 @@ export function useThursday() {
     setTool({
       name: call.name,
       line: toolLine(call.name, call.arguments),
+      bot: toolBot(call.name, call.arguments),
       done: false,
     });
   }, []);
@@ -343,11 +354,15 @@ export function useThursday() {
     },
     tasks: () => void revalidate(queryKey.tasks),
     memory: () => void revalidate(queryKey.memory),
-    "memory-tidy": () => void revalidate(queryKey.memoryTidy),
     mcp: () => {
       void revalidate(queryKey.mcp);
       void revalidate(queryKey.mcpTools);
     },
+    // A sign-in finished in its own window (ai/chatgpt): the key rows and the model picker both read it
+    config: () => {
+      void revalidate(queryKey.config);
+      void revalidate(queryKey.llmModel);
+    },
   });
 
   // faces come from the bot list
@@ -356,23 +371,28 @@ export function useThursday() {
     if (tasks) botTasks.sync(tasks, bots);
   }, [tasks, bots]);
 
-  // Finished or waiting tasks are relayed once. Sending while the line is still
-  // opening is fine: the outbox holds the line. `status` is in deps because the
-  // guard is a ref; without it a list that arrived before the line opened
-  // would wait for the next tasks change
+  // A question is relayed on every call, because it still needs an answer. An
+  // ending is relayed only on the call it happened during: one from before is
+  // already in her prompt, on the `delegate` line that opened it. Telling is not
+  // seeing — the badge clears when the user opens the job. Sending while the
+  // line is still opening is fine: the outbox holds the line. `status` is in
+  // deps because the guard is a ref; without it a list that arrived before the
+  // line opened would wait for the next tasks change
   useEffect(() => {
     if (!tasks || !calling.current) return;
     for (const task of tasks) {
-      if (task.status === "running" || task.reported) continue;
+      if (task.status === "running") continue;
+      // A stop the app picks back up by itself is not news: it runs again in a moment
+      if (task.ask?.auto) continue;
+      if (
+        task.status !== "waiting" &&
+        toDate(task.updatedAt).getTime() < placedAt.current
+      )
+        continue;
       const key = relayKey(task);
       if (relayed.current.has(key)) continue;
       relayed.current.add(key);
-      // marked reported when the line is actually sent (outbox callback), not here
-      outbox.send({
-        line: relayLine(task),
-        mark: task.id,
-        show: relayShow(task),
-      });
+      outbox.send({ line: relayLine(task), show: relayShow(task) });
     }
   }, [tasks, outbox, status]);
 
@@ -385,7 +405,7 @@ export function useThursday() {
           line:
             act.kind === "answered"
               ? `The user answered task "${act.label}" on screen: ${act.answer}. The bot is going on with that — do not ask again.`
-              : `The user stopped task "${act.label}" on screen. It is not running any more — do not wait for it or report on it.`,
+              : `The user stopped task "${act.label}" on screen. It is not running any more — do not wait for it or say anything more about it.`,
         });
       }),
     [outbox],
@@ -401,7 +421,7 @@ export function useThursday() {
     calling.current = false;
     opening.current = false;
     relayed.current.clear();
-    // unsent lines belong to tasks still not reported; the next call resends them
+    // unsent lines go: a question is relayed again next call, an ending is in her prompt
     outbox.close();
     outbox.clear();
     // holds the closed session; the next call sets its own
@@ -414,7 +434,7 @@ export function useThursday() {
     // a pending face timer must not fire after the call
     restFace();
     if (idle.current.grace) clearTimeout(idle.current.grace);
-    idle.current = { since: 0, asked: false, grace: null };
+    idle.current = { since: 0, asked: false, owed: null, grace: null };
     setIdleLeft(null);
     setSince(null);
     setStatus("idle");
@@ -459,8 +479,17 @@ export function useThursday() {
    * agent activity does not, so the goodbye cannot cancel itself.
    */
   const stir = useCallback((who: "user" | "agent") => {
-    idle.current.since = Date.now();
-    if (who !== "user") return;
+    const now = Date.now();
+    idle.current.since = now;
+    if (who !== "user") {
+      // Words or a tool: she is on the line, so nothing is owed.
+      idle.current.owed = null;
+      return;
+    }
+    // Rewound by anything the user does, transcript deltas included, so a long
+    // turn is never mistaken for a line that stopped answering; it runs from the
+    // moment they stopped rather than from the moment they started.
+    idle.current.owed = now;
     if (idle.current.grace) clearTimeout(idle.current.grace);
     idle.current.grace = null;
     idle.current.asked = false;
@@ -473,6 +502,17 @@ export function useThursday() {
     const tick = setInterval(() => {
       const live = session.current;
       if (!live) return;
+      const owed = idle.current.owed;
+      if (owed !== null && Date.now() - owed >= AGENT_SILENT_MS) {
+        // Nothing to say goodbye with; the model is what would have said it.
+        toast.add({
+          type: "error",
+          title: "Call ended",
+          description: "The model stopped answering.",
+        });
+        void hangUp();
+        return;
+      }
       const left = IDLE_HANG_UP_MS - (Date.now() - idle.current.since);
       setIdleLeft(
         left <= IDLE_WARN_MS && !idle.current.asked
@@ -499,6 +539,7 @@ export function useThursday() {
     // from here on this is a call; the outbox holds lines until the session exists
     opening.current = true;
     calling.current = true;
+    placedAt.current = Date.now();
     outbox.clear();
     try {
       const handshake = unwrapResult(await openCallAction(thursdaySettings()));
@@ -601,8 +642,6 @@ export function useThursday() {
         live.say(queued.length === 1 ? queued[0].line : mergedRelay(queued));
         const last = queued.at(-1)?.show;
         if (last) showRelay(last);
-        const marks = queued.flatMap((one) => one.mark ?? []);
-        if (marks.length) markReported(marks);
         outbox.close();
       };
 
@@ -669,7 +708,8 @@ export function useThursday() {
     if (!tasks) return;
     const wants = tasks.filter(
       (task) =>
-        !task.reported &&
+        !task.seen &&
+        !task.ask?.auto &&
         (asksSomething(task) ||
           (callBack === "any" && task.status !== "running")),
     );
@@ -809,25 +849,12 @@ function persistTurn(
     });
 }
 
-/** Failure surfaces as a toast: an unmarked report is read again next call. */
-function markReported(ids: string[]) {
-  markReportedAction(ids)
-    .then(unwrapResult)
-    .catch((cause) =>
-      toast.add({
-        type: "error",
-        title: "Could not mark the report as delivered",
-        description: errorToString(cause),
-      }),
-    );
-}
-
 /**
- * Waiting on a real question. A budget ask (out of steps) waits in the inbox
+ * Waiting on a real question. A job the app stopped waits in the inbox
  * instead of ringing.
  */
 function asksSomething(task: Task) {
-  return task.status === "waiting" && !isBudgetAsk(task.ask);
+  return task.status === "waiting" && !isAppStop(task.ask);
 }
 
 /**
@@ -835,16 +862,16 @@ function asksSomething(task: Task) {
  * sender and recipient or the model answers it as user speech.
  */
 function relayLine(task: Task) {
-  // The label travels with the report: what the user says next about this job
+  // The label travels with the answer: what the user says next about this job
   // is a word to it, and the task tool takes it by that name
   const from = `[${task.bot} → you, about "${task.label}" — not the user speaking; they have not heard this. Anything more on this job goes to the task tool as "${task.label}", never a new job.]`;
   switch (task.status) {
     case "waiting": {
-      // a budget ask is reported, not read as a question
+      // a stop is told, not read as a question
       const options = task.ask?.options ?? [];
       const said = task.ask?.question ?? task.outcome ?? "";
-      if (isBudgetAsk(task.ask)) {
-        return `${from} Out of steps. Where it got to: ${said} Ask whether to keep going; if yes, send "${TASK_CONTINUE}" with the task tool.`;
+      if (isAppStop(task.ask)) {
+        return `${from} It stopped before finishing. Where it got to: ${said} Ask whether to keep going; if yes, send "${TASK_CONTINUE}" with the task tool.`;
       }
       const list = options.length ? ` Options: ${options.join(" / ")}.` : "";
       return `${from} It asks: ${said}${list} Answer with the task tool if you can; otherwise ask the user and send back what they say.`;
@@ -852,7 +879,7 @@ function relayLine(task: Task) {
     case "failed":
       return `${from} It could not finish: ${task.outcome ?? ""}`;
     default:
-      return `${from} Done. Its report: ${task.outcome ?? ""}`;
+      return `${from} Done. Its answer: ${task.outcome ?? ""}`;
   }
 }
 
@@ -871,13 +898,13 @@ ${queued.map((one) => one.line).join("\n\n")}`;
 function relayShow(task: Task): ToolRun {
   const line =
     task.status === "waiting"
-      ? isBudgetAsk(task.ask)
-        ? `${task.bot} is out of steps`
+      ? isAppStop(task.ask)
+        ? `${task.bot} stopped`
         : `${task.bot} is asking`
       : task.status === "failed"
         ? `${task.bot} could not finish`
-        : `Report from ${task.bot}`;
-  return { kind: "relay", name: task.label, line, done: true };
+        : `Answer from ${task.bot}`;
+  return { kind: "relay", name: task.label, line, done: true, bot: task.bot };
 }
 
 export type { CallMessage, CallStatus };

package/features/workspace/components/file-view.tsx

@@ -158,10 +158,12 @@ export function FileLink({
 const PAD: Record<FileViewPlace, { prose: string; block: string }> = {
   dialog: { prose: "px-5 py-4", block: "px-4 py-3" },
   page: { prose: "px-5 py-6 sm:px-8", block: "px-5 py-5" },
+  // Opened under a list row, which already sets the edges
+  inline: { prose: "pb-3", block: "pb-3" },
 };
 
-/** Where the file is read: inside the dialog or on its own page. */
-export type FileViewPlace = "dialog" | "page";
+/** Where the file is read: inside the dialog, on its own page, or opened in place under a row. */
+export type FileViewPlace = "dialog" | "page" | "inline";
 
 export function FileBody({
   kind,