thursday-agent 0.3.0 → 0.4.0

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

@@ -1,6 +1,5 @@
 import { tool } from "ai";
 import * as z from "zod";
-import { appEvents } from "@/app/api/events/app-event.server";
 import { MEMORY_CONVERSATION_PAGE, MEMORY_LIMITS } from "@/config";
 import {
   callStamp,
@@ -57,9 +56,9 @@ const noConversation = (source: MemorySource | null) =>
 /**
  * Said when a note has outgrown the recommended size, and only then — the write
  * itself always goes through. It names no tool: this one answers the call and a
- * bot, and only one of them has a screen to put a note on. How to do it is the
- * call prompt's (prompts/thursday.prompt); the ask is the same either way,
- * because a bot that turned up a fact can hand the same request back with it.
+ * bot, and how to settle it with the user is the call's to say (prompts/thursday.prompt);
+ * the ask is the same either way, because a bot that turned up a fact can hand
+ * the same request back with it.
  */
 const overSize = (count: number) =>
   count > MEMORY_LIMITS.factsPerNote
@@ -114,7 +113,9 @@ export const createMemoryTools = (
         .object({
           text: z
             .string()
-            .describe("One statement that stands on its own later."),
+            .describe(
+              'One statement that stands on its own later — a date as a date, never "next week".',
+            ),
           replaces: z
             .number()
             .int()
@@ -126,7 +127,7 @@ export const createMemoryTools = (
             .boolean()
             .nullish()
             .describe(
-              `True carries this line into every call's instructions without opening its note — for what to call them, their language and register, a standing rule. At most ${MEMORY_LIMITS.carried}. Null leaves it; false makes a carried line an ordinary fact.`,
+              `True carries this line into every call's instructions without opening its note — for what every call needs before any note is opened: what to call them, their language and register. At most ${MEMORY_LIMITS.carried}. Null leaves it; false makes a carried line an ordinary fact.`,
             ),
         })
         .array()
@@ -175,23 +176,23 @@ export const createMemoryTools = (
         };
       }
       // A new path outside the convention goes to inbox, which keeps its own line and takes no aliases
-      const filed =
-        known || isMemoryPath(said)
-          ? { path: target, description, aliases, facts }
-          : {
-              path: MEMORY_INBOX,
-              description: appNoteLine(MEMORY_INBOX),
-              facts,
-            };
+      const toInbox = !known && !isMemoryPath(said);
+      const filed = toInbox
+        ? {
+            path: MEMORY_INBOX,
+            description: appNoteLine(MEMORY_INBOX),
+            facts,
+          }
+        : { path: target, description, aliases, facts };
 
       const write = await writeNotes([filed], source, callId);
 
       // The write already succeeded; what follows are requests, not failures.
-      // A path filed elsewhere must be said, or the model reports it saved where it asked.
-      const elsewhere =
-        filed.path !== said
-          ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
-          : "";
+      // Only a path that landed in inbox is said: one reached by a name the
+      // listing carries is where it was asked for, however it was spelled.
+      const elsewhere = toInbox
+        ? ` Filed under ${filed.path}: "${said}" is not a path this listing can carry. If that is not where it belongs, write it again under one that is.`
+        : "";
 
       const unnamed = write.unnamed.length
         ? ` ${write.unnamed[0]} is new and has no line yet — the listing shows its first fact instead. Call again with \`description\` (one line about what it is) and \`aliases\` (the names they say for it).`
@@ -265,59 +266,61 @@ export const createMemoryTools = (
     },
   }),
 
-  [TOOL_NAMES.memory_show]: tool({
-    description: `Put a note on the user's screen so they can see it while you
-talk about it, and take it away again. They cannot edit it there — they say
-what to drop and you drop it.`,
-    inputSchema: z.object({
-      path: z
-        .string()
-        .nullable()
-        .describe(
-          "The note to put on screen, exactly as the listing writes it. Null takes it away.",
-        ),
-    }),
-    execute: async ({ path }) => {
-      if (!path?.trim()) {
-        appEvents.emit({ type: "memory-view", path: null });
-        return { note: "Taken off the screen." };
-      }
-      // The screen gets only the path and reads facts over GET, so deletions show up on their own
-      const { notes } = await readNotes([path], { touch: false });
-      const note = notes[0];
-      if (!note) {
-        return { note: `Nothing on the listing called ${path.trim()}.` };
-      }
-      appEvents.emit({ type: "memory-view", path: note.path });
-      return {
-        ...note,
-        note: "It is on their screen now, in this order. Ask what they no longer need, and forget only what they name.",
-      };
-    },
-  }),
-
   [TOOL_NAMES.memory_forget]: tool({
-    description: "Delete one fact for good.",
+    description: "Delete facts for good.",
     inputSchema: z.object({
-      factId: z
+      factIds: z
         .number()
         .int()
-        .describe("The id that came with the fact when the note was opened."),
+        .array()
+        .min(1)
+        .describe(
+          "The ids that came with the facts when their notes were opened — every one to delete, in one call.",
+        ),
     }),
-    execute: async ({ factId }) => {
-      const forgotten = await forgetFactById(factId);
-      if (!forgotten) {
-        return { note: `No fact with id ${factId}. Nothing was deleted.` };
+    execute: async ({ factIds }) => {
+      const missing: number[] = [];
+      /** Notes that lost their last fact, and went with it (memory.query forgetFactById). */
+      const gone: string[] = [];
+      /** Notes that still hold something, handed back as they are now. */
+      const left = new Set<string>();
+      for (const id of new Set(factIds)) {
+        const forgotten = await forgetFactById(id);
+        if (!forgotten) {
+          missing.push(id);
+          continue;
+        }
+        if (forgotten.noteGone) {
+          left.delete(forgotten.path);
+          gone.push(forgotten.path);
+        } else {
+          left.add(forgotten.path);
+        }
       }
 
-      // The note goes with its last fact; the listing still shows it until the next session, so say so
-      if (forgotten.noteGone) {
+      if (!gone.length && !left.size) {
         return {
-          note: `${GONE} That was the last fact under ${forgotten.path}, so the note went with it.`,
+          note: `No fact with id ${missing.join(", ")}. Nothing was deleted.`,
         };
       }
-      const { notes } = await readNotes([forgotten.path], { touch: false });
-      return { ...notes[0], note: GONE };
+
+      // The notes that went are still on the listing until the next session, so say so
+      const said = [
+        GONE,
+        gone.length === 1
+          ? `That was the last fact under ${gone[0]}, so the note went with it.`
+          : gone.length
+            ? `That was the last of ${gone.join(", ")}, so those notes went with them.`
+            : "",
+        missing.length
+          ? `No fact with id ${missing.join(", ")}, so those were skipped.`
+          : "",
+      ]
+        .filter(Boolean)
+        .join(" ");
+      if (!left.size) return { note: said };
+      const { notes } = await readNotes([...left], { touch: false });
+      return { notes: notes.map(withCount), note: said };
     },
   }),
 });

package/features/ai/tools/tool-name.ts

@@ -7,7 +7,6 @@ export const TOOL_NAMES = {
   memory_recall: "memory_recall",
   memory_remember: "memory_remember",
   memory_forget: "memory_forget",
-  memory_show: "memory_show",
   memory_conversation: "memory_conversation",
 
   bash: "bash",

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

@@ -18,6 +18,8 @@ export const createWorkspaceTools = (
     env?: Record<string, string>;
     /** Attach the shell guide to this run's first `bash` result (bots only). */
     guide?: boolean;
+    /** How long one command may run; unset is the sandbox's own limit (config EXEC_TIMEOUT_MS). */
+    timeoutMs?: number;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -45,6 +47,7 @@ export const createWorkspaceTools = (
       const result = await sandbox.exec(command, {
         signal: abortSignal,
         env: options.env,
+        timeoutMs: options.timeoutMs,
       });
       if (!owed) return result;
       owed = false;

package/features/bot/bot.action.ts

@@ -110,7 +110,12 @@ export const startTaskAction = serverAction(
     const worker = await findBot(bot);
     if (!worker) publicError(`No bot called "${bot}".`);
     const label = labelFor(said);
-    const id = await startTask({ bot: worker.name, request: said, label });
+    const id = await startTask({
+      bot: worker.name,
+      request: said,
+      label,
+      from: "user",
+    });
     return { id, label, bot: worker.name };
   },
 );

package/features/bot/bot.run.ts

@@ -344,6 +344,7 @@ export async function runBot(
         const summary = await compact(model.model, agentTools, messages, {
           signal: options.signal,
           budget,
+          instructions: prompt.text,
         }).finally(quiet.release);
         logger.debug(
           `compacted ${messages.length} messages at ${size} tokens (budget ${budget})`,
@@ -701,17 +702,19 @@ async function filesUnder(
 /**
  * The model summarizes its own context and continues from the summary. Tools
  * are passed with calling off: providers refuse a history of tool calls
- * without the tools that made them. A context too long to summarise whole —
- * the very thing a compaction is for — is tried once more without the tool
- * calls and results but the last few. A failure throws with its cause kept:
- * the runner parks what a retry or a smaller budget can fix (bot.runner
- * parkTask) and fails the rest; the thread stays.
+ * without the tools that made them. The run's own instructions go too: the
+ * summary is written by the bot the thread belongs to, and the provider's
+ * cached prefix, instructions first, still matches the run's. A context too
+ * long to summarise whole — the very thing a compaction is for — is tried once
+ * more without the tool calls and results but the last few. A failure throws
+ * with its cause kept: the runner parks what a retry or a smaller budget can
+ * fix (bot.runner parkTask) and fails the rest; the thread stays.
  */
 async function compact(
   model: LanguageModel,
   tools: ToolSet,
   messages: ModelMessage[],
-  options: { signal?: AbortSignal; budget: number },
+  options: { signal?: AbortSignal; budget: number; instructions: string },
 ): Promise<{ text: string; usage: TokenUsage }> {
   let failure: unknown;
   try {
@@ -745,10 +748,11 @@ async function summarize(
   model: LanguageModel,
   tools: ToolSet,
   messages: ModelMessage[],
-  options: { signal?: AbortSignal; budget: number },
+  options: { signal?: AbortSignal; budget: number; instructions: string },
 ): Promise<{ text: string; usage: TokenUsage }> {
   const { text, usage } = await generateText({
     model,
+    system: options.instructions,
     tools,
     toolChoice: "none",
     messages: [

package/features/bot/bot.runner.ts

@@ -34,7 +34,13 @@ 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 {
+  TASK_CONTINUE,
+  type TaskPending,
+  type TaskSpeaker,
+  type TaskStatus,
+  tagSpeaker,
+} from "./bot.schema";
 import {
   addTaskUsage,
   countStopsSinceSpoken,
@@ -49,6 +55,7 @@ import {
   listRunningTaskIds,
   listTaskFolders,
   listThread,
+  stopNote,
   type TaskMessageInput,
   updateTask,
   upsertMessage,
@@ -99,24 +106,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 +139,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 +169,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, {
@@ -465,7 +487,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 +507,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`

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.
@@ -688,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;
 
 /**
@@ -710,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") {
@@ -817,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

@@ -24,7 +24,11 @@ import { errorToString } from "@/lib/utils";
 
 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"
@@ -32,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 = {
@@ -63,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. */
@@ -159,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({
@@ -264,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;
 }
@@ -412,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,