thursday-agent 0.4.0 → 0.6.0

package/features/thursday/use-thursday.ts

@@ -4,57 +4,51 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useAppEvent } from "@/app/api/events/app-event.client";
 import { queryKey } from "@/app/api/query-key";
 import { toast } from "@/components/ui/toast";
+import { CALL_END, CALL_IDLE, CALL_RELAY } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
-import {
-  type Bot,
-  isAppStop,
-  TASK_CONTINUE,
-  type Task,
-} from "@/features/bot/bot.schema";
-import { MARK_BANDS } from "@/features/bot/mark.const";
-import { botTasks, screenActs } from "@/features/bot/task.store";
+import { acceptThreadRelaysAction } from "@/features/bot/bot.action";
+import { type Bot, isAppStop, type Thread } from "@/features/bot/bot.schema";
+import { botThreads, screenActs } from "@/features/bot/thread.store";
 import { runRemoteTool } from "@/features/thursday/tool-call";
 import { isCombo, useHotkey } from "@/hooks/use-hotkey";
 import { useWakeWord } from "@/hooks/use-wake-word";
 import { toDate } from "@/lib/date-like";
-import { unwrapResult } from "@/lib/protocol/result";
+import type { LiveClose } from "@/lib/live/live.schema";
+import {
+  type LiveActivity,
+  type LiveSession,
+  type LiveToolCall,
+  openLiveSession,
+} from "@/lib/live/live.session";
+import {
+  type AudioTap,
+  createAudioTap,
+  SPECTRUM_BANDS,
+} from "@/lib/live/live.tap";
+import { type Result, unwrapResult } from "@/lib/protocol/result";
 import {
   revalidate,
   revalidateAll,
   useServerRoute,
 } from "@/lib/protocol/use-server-route";
 import { createOutbox, type Outbox } from "@/lib/queue";
-import { openRealtimeSession } from "@/lib/realtime/open-session";
-import type {
-  RealtimeActivity,
-  RealtimeSession,
-  RealtimeToolCall,
-} from "@/lib/realtime/realtime.session";
-import { type AudioTap, createAudioTap } from "@/lib/realtime/realtime.tap";
 import { errorToString } from "@/lib/utils";
 import {
   endCallAction,
   openCallAction,
+  saveThoughtAction,
   saveTurnsAction,
 } from "./thursday.action";
-import type {
-  CallMessage,
-  CallStatus,
-  CallTurn,
-  LiveStatus,
-} from "./thursday.schema";
+import type { CallMessage, CallStatus, LiveStatus } from "./thursday.schema";
 import { thursdaySettings, useThursdayStore } from "./thursday.store";
 import { toolBot, toolLine } from "./tool-line";
 
 /**
- * One live call, plus the task inbox the app watches even with no call open.
- * The server picks the provider (openCallAction) and runs the tools (tool-call);
- * the page itself only hangs up.
+ * One live call, plus the thread inbox the app watches even with no call open.
+ * The server opens the Live session (openCallAction) and runs the tools
+ * (tool-call); the page itself only hangs up.
  */
 
-/** Time for a tool result to reach the model before the socket closes. */
-const HANG_UP_DELAY_MS = 400;
-
 /** Plays when the line opens. */
 const CONNECTED_SOUND = "/sounds/start_voice.ogg";
 
@@ -69,6 +63,13 @@ const TOOL_LINGER_MS = 2500;
 /** A relay from a bot carries more to read than a tool line. */
 const RELAY_LINGER_MS = 5000;
 
+/**
+ * Once the backend's turn is over, how long the activity line keeps saying it is
+ * working while it waits for her voice. Her first word is what normally ends it;
+ * this is only for a turn that never reaches one.
+ */
+const THINKING_TAIL_MS = 6000;
+
 /**
  * The face lags the activity line: only a tool held longer than this switches
  * to the working face. Shorter tools show on the line only.
@@ -81,92 +82,88 @@ const FACE_TOOL_MS = 800;
  */
 const FACE_SETTLE_MS = 600;
 
-/** Scrollback for the side-by-side layout; the call view shows at most three. */
-const KEEP_MESSAGES = 24;
-
-/** Safety net only; the event stream revalidates tasks as they change. */
-const TASK_POLL_FALLBACK_MS = 30_000;
-
-/** Notify once about failing saves, then stay quiet for the rest of the call. */
-const SAVE_FAILURE_LIMIT = 3;
-
 /**
- * With no user speech, agent speech, or tool for this long, the model is asked
- * to say goodbye and call end_call.
+ * How long the face says a call failed to open or dropped before it rests: long
+ * enough for the orb to spell its ERROR out. The toast carries the reason.
  */
-const IDLE_HANG_UP_MS = 60_000;
-
-/** If end_call does not follow the goodbye, the page hangs up. */
-const IDLE_GRACE_MS = 15_000;
+const FAILED_FACE_MS = 6000;
 
-/** The countdown shows on screen inside this window. */
-const IDLE_WARN_MS = 15_000;
+/** Scrollback for the side-by-side layout; the call view shows at most three. */
+const KEEP_MESSAGES = 24;
 
-/**
- * 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;
+/** Safety net only; the event stream revalidates threads as they change. */
+const THREAD_POLL_FALLBACK_MS = 30_000;
 
-const IDLE_LINE =
-  "The user has said nothing for a minute. Say a one-line goodbye, then call end_call.";
+/** Failed saves of one kind before the call stops saving that kind and says so, once. */
+const SAVE_FAILURE_LIMIT = 3;
 
 /**
- * Upper bound on the mic staying muted for a relayed line the model never
- * voices (the response can be rejected).
+ * Put in as trusted behaviour just ahead of the first relay of a call. The relay
+ * itself carries facts only, since the backend reads relays too and routes answers
+ * by them.
  */
-const RELAY_MIC_MS = 15_000;
+const RELAY_NOTE =
+  "An update from background work follows. If you have already told the user what it says, it need not be said again.";
 
-/** A line queued for the model. */
-type Said = {
-  line: string;
-  /** Shown on the activity line when the line is sent. */
-  show?: ToolRun;
-};
+const IDLE_LINE = `The user has said nothing for ${Math.round(CALL_IDLE.hangUpMs / 1000)} seconds. Say a one-line goodbye and end the call.`;
 
 /**
- * A tool the model is using, as the activity line draws it. `line` is the
- * human-readable sentence (tool-line), null when none exists; `name` is the
+ * What the activity line draws: a tool the model is using, or a relay. `line` is
+ * the human-readable sentence (tool-line), null when none exists; `name` is the
  * tool that actually ran.
  */
-export type ToolRun = {
+export type ActivityLine = {
   name: string;
   line: string | null;
   done: boolean;
-  /** A relay from a bot (answer or question) rather than a tool; `name` is the task label. */
-  kind?: "tool" | "relay";
+  /** The tool call this is, so one call finishing never ends another's line. */
+  id?: string;
+  /** A relay from a bot (answer or question) rather than a tool; `name` is the thread label. */
+  kind?: "relay";
   /** The bot this names, when it names one: the row draws its face instead of a glyph. */
   bot?: string | null;
 };
 
 export function useThursday() {
-  const session = useRef<RealtimeSession | null>(null);
+  const session = useRef<LiveSession | null>(null);
   // created on the first call: `new Audio()` cannot run during SSR
   const tap = useRef<AudioTap | null>(null);
   /** Created inside the call-starting click; hang-up may come from a tool or a disconnect with no gesture. */
   const farewell = useRef<HTMLAudioElement | null>(null);
 
   const [status, setStatus] = useState<CallStatus>("idle");
+  /** A call just failed to open or dropped; the face says so for FAILED_FACE_MS. */
+  const [failed, setFailed] = useState(false);
+  const failedFor = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const showFailed = useCallback((on: boolean) => {
+    if (failedFor.current) clearTimeout(failedFor.current);
+    failedFor.current = on
+      ? setTimeout(() => setFailed(false), FAILED_FACE_MS)
+      : null;
+    setFailed(on);
+  }, []);
   const [messages, setMessages] = useState<CallMessage[]>([]);
-  const [tool, setTool] = useState<ToolRun | null>(null);
+  const [tool, setTool] = useState<ActivityLine | null>(null);
   /** When the line opened (ms). */
   const [since, setSince] = useState<number | null>(null);
-  /** Seconds until idle hang-up; set only inside IDLE_WARN_MS. */
+  /** Seconds until idle hang-up; set only inside CALL_IDLE.warnMs. */
   const [idleLeft, setIdleLeft] = useState<number | null>(null);
+  /** When the backend picked this turn up (ms); the activity line counts from it. */
+  const [thinkingSince, setThinkingSince] = useState<number | null>(null);
+  /** The same value where callbacks can read it, and the timer that ends it. */
+  const thinking = useRef<number | null>(null);
+  const thinkTail = useRef<ReturnType<typeof setTimeout> | null>(null);
   /**
-   * Mic is muted while a tool runs and while a relayed line is being read.
-   * The effect below applies it to the session.
+   * A relayed update is out and has not been voiced yet: nothing else goes in
+   * until her voice has started and stopped.
    */
-  const [micOff, setMicOff] = useState(false);
-  /** The two mute reasons, and whether the relayed line has produced audio yet. */
-  const mic = useRef<{
-    tool: boolean;
-    reading: boolean;
+  const reading = useRef<{
+    on: boolean;
     spoke: boolean;
     giveUp: ReturnType<typeof setTimeout> | null;
-  }>({ tool: false, reading: false, spoke: false, giveUp: null });
+  }>({ on: false, spoke: false, giveUp: null });
+  /** What `session.closed` confirmed for the call being ended; recorded on its row. */
+  const finalized = useRef<LiveClose | null>(null);
   /**
    * Last activity time, whether the goodbye was requested, and when an answer
    * started being owed (null once she answers or works).
@@ -178,30 +175,53 @@ export function useThursday() {
     grace: ReturnType<typeof setTimeout> | null;
   }>({ since: 0, asked: false, owed: null, grace: null });
   const linger = useRef<ReturnType<typeof setTimeout> | null>(null);
+  /** Whether the line holds a relay, so only a relay is finished by her voice. */
+  const relayOpen = useRef(false);
   // 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
+  // reaches running browser commands. Delegated threads are server-owned and outlive the call
   const working = useRef<AbortController | null>(null);
   /** Row the turns are saved to; a ref so long-lived callbacks see it. */
   const callId = useRef<string | null>(null);
   /**
-   * Relays sent this call, keyed by relayKey (id + updatedAt): an answered task
-   * can stop to ask again, so the id alone would silence its second question.
+   * Open work put to her while this page has been open, by item key (openWork):
+   * each goes in once a call. A key carries its job's last change, so a job that
+   * asks or ends again is new work.
    */
-  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);
+  const told = useRef(new Set<string>());
   /**
-   * Lines for the model, including ones raised before the line opens. Held
-   * until the session exists, which is also what lets a call-back queue its
-   * line first.
+   * Keys put in this call that her voice has not carried yet: rejected, cut short
+   * by a hang-up, or never spoken. Hanging up takes them out of `told`, so the
+   * next call puts them in again; what she voiced stays out.
    */
-  const outboxRef = useRef<Outbox<Said> | null>(null);
-  const outbox = (outboxRef.current ??= createOutbox<Said>());
+  const unvoiced = useRef(new Set<string>());
+  /** The keys of the update on the line now, carried once her voice starts and stops on it. */
+  const onLine = useRef<string[]>([]);
   /**
-   * Sends what piled up while she was reading the last line, as one line. Set
-   * for the length of a session; null between calls.
+   * When her voice was last heard: for letting a goodbye finish (CALL_END), and for
+   * telling words she already answered from words still owed an answer.
    */
-  const resumeRelay = useRef<(() => void) | null>(null);
+  const voiced = useRef(0);
+  /** The relay note went in on this call (RELAY_NOTE). */
+  const relayNoted = useRef(false);
+  /** The hang-up waiting on her goodbye once the backend called end_call. */
+  const leaving = useRef<ReturnType<typeof setInterval> | null>(null);
+  /** When either side's words were last transcribed: the quiet clock for relays. */
+  const heard = useRef(0);
+  /**
+   * The call-back placed this call and its first relay has not gone in yet: that one
+   * goes in once she has voiced the opening rather than waiting for a quiet line.
+   */
+  const rang = useRef(false);
+  /** Backend work or a call tool is running, as the last activity said. */
+  const acting = useRef(false);
+  /** The inbox as last fetched, read by the relay clock. */
+  const latest = useRef<Thread[] | undefined>(undefined);
+  /**
+   * Context she need not say (screen acts), including what arrives before the
+   * line opens. Held until the session exists.
+   */
+  const outboxRef = useRef<Outbox<string> | null>(null);
+  const outbox = (outboxRef.current ??= createOutbox<string>());
   /** Wants a call, including while connecting. */
   const calling = useRef(false);
   /**
@@ -210,10 +230,18 @@ export function useThursday() {
    * in `call` or the hang-up press is swallowed too.
    */
   const opening = useRef(false);
+  const ending = useRef(false);
+  /**
+   * Which attempt owns the line. A hang-up during startup moves it on, so an
+   * attempt still connecting cannot come up after a newer call has been placed.
+   */
+  const attempt = useRef(0);
 
-  const showTool = useCallback((call: RealtimeToolCall) => {
+  const showTool = useCallback((call: LiveToolCall) => {
     if (linger.current) clearTimeout(linger.current);
+    relayOpen.current = false;
     setTool({
+      id: call.id,
       name: call.name,
       line: toolLine(call.name, call.arguments),
       bot: toolBot(call.name, call.arguments),
@@ -221,21 +249,22 @@ export function useThursday() {
     });
   }, []);
 
-  /** A relay takes the tool line and stays long enough to read. */
-  const showRelay = useCallback((run: ToolRun) => {
+  /**
+   * A relay takes the tool line and runs there like a tool does: while it goes in,
+   * and while she voices it. Her voice finishing it is what stops the motion
+   * (doneReading); after that it stays long enough to read.
+   */
+  const showRelay = useCallback((run: ActivityLine) => {
     if (linger.current) clearTimeout(linger.current);
-    setTool(run);
-    linger.current = setTimeout(
-      () => setTool((open) => (open?.kind === "relay" ? null : open)),
-      RELAY_LINGER_MS,
-    );
+    relayOpen.current = true;
+    setTool({ ...run, done: false });
   }, []);
 
   /** Tool finished; lingers, then clears. */
-  const hideTool = useCallback((name: string) => {
+  const hideTool = useCallback((id: string) => {
     setTool((open) =>
       // a second tool already took the line; leave it
-      open?.name === name ? { ...open, done: true } : open,
+      open?.id === id ? { ...open, done: true } : open,
     );
     if (linger.current) clearTimeout(linger.current);
     linger.current = setTimeout(
@@ -244,36 +273,144 @@ export function useThursday() {
     );
   }, []);
 
-  /** The effect below is the only place that touches the session mute. */
-  const syncMic = useCallback(() => {
-    setMicOff(mic.current.tool || mic.current.reading);
+  /** The relayed update was voiced, or waited on long enough: the next can go in. */
+  const doneReading = useCallback(() => {
+    if (reading.current.giveUp) clearTimeout(reading.current.giveUp);
+    // Her voice started and stopped on it: carried
+    if (reading.current.spoke) {
+      for (const key of onLine.current) unvoiced.current.delete(key);
+    }
+    onLine.current = [];
+    reading.current = { on: false, spoke: false, giveUp: null };
+    if (!relayOpen.current) return;
+    relayOpen.current = false;
+    setTool((open) =>
+      open?.kind === "relay" ? { ...open, done: true } : open,
+    );
+    if (linger.current) clearTimeout(linger.current);
+    linger.current = setTimeout(
+      () => setTool((open) => (open?.kind === "relay" ? null : open)),
+      RELAY_LINGER_MS,
+    );
   }, []);
 
-  const openMic = useCallback(() => {
-    if (mic.current.giveUp) clearTimeout(mic.current.giveUp);
-    mic.current.giveUp = null;
-    mic.current.reading = false;
-    mic.current.spoke = false;
-    syncMic();
-  }, [syncMic]);
-
-  /** A relayed line is on the wire; the mic stays muted until it is read. */
+  /** An update is on the wire: nothing else goes in until she has voiced it. */
   const readAloud = useCallback(() => {
-    if (mic.current.giveUp) clearTimeout(mic.current.giveUp);
-    mic.current.reading = true;
-    mic.current.spoke = false;
-    mic.current.giveUp = setTimeout(() => {
-      openMic();
-      // a line she never voiced must not strand the ones queued behind it
-      resumeRelay.current?.();
-    }, RELAY_MIC_MS);
-    syncMic();
-  }, [openMic, syncMic]);
-
-  // muting at the track level also clears the browser's recording indicator (realtime.audio setMuted)
-  useEffect(() => {
-    session.current?.mute(micOff);
-  }, [micOff]);
+    if (reading.current.giveUp) clearTimeout(reading.current.giveUp);
+    reading.current = {
+      on: true,
+      spoke: false,
+      giveUp: setTimeout(doneReading, CALL_RELAY.readMs),
+    };
+  }, [doneReading]);
+
+  const setThinking = useCallback((at: number | null) => {
+    thinking.current = at;
+    setThinkingSince(at);
+  }, []);
+
+  /**
+   * What the activity line says about the backend. It starts when the backend takes the
+   * turn and ends on her first word, not on the response: a turn that calls two
+   * tools settles for a moment between them, and the wait before she speaks is
+   * still the same stretch of work. Both would otherwise read as the call stalling.
+   */
+  const holdThinking = useCallback(
+    (busy: boolean, speaking: boolean) => {
+      const dropTail = () => {
+        if (thinkTail.current) clearTimeout(thinkTail.current);
+        thinkTail.current = null;
+      };
+      // Her voice always wins: it is the answer the work was for
+      if (speaking) {
+        dropTail();
+        if (thinking.current !== null) setThinking(null);
+        return;
+      }
+      if (busy) {
+        dropTail();
+        if (thinking.current === null) setThinking(Date.now());
+        return;
+      }
+      if (thinking.current !== null && !thinkTail.current) {
+        thinkTail.current = setTimeout(() => {
+          thinkTail.current = null;
+          setThinking(null);
+        }, THINKING_TAIL_MS);
+      }
+    },
+    [setThinking],
+  );
+
+  /**
+   * Puts to her what background work still waits on the user, once neither
+   * side's words have been transcribed for CALL_RELAY.quietMs and nothing is
+   * running: questions not answered, jobs ended or stopped and not yet seen,
+   * and progress from jobs still running. Live never speaks unprompted, so
+   * nothing reaches the user unless this puts it in. Handling an item — an
+   * answer, `thread` `seen`, a click on screen — takes it off the list. Each
+   * item goes in once a call, and once her voice has carried it, not on later
+   * calls either (`told`, `unvoiced`). One append holds one kind, so an ending
+   * is never lost among questions. Nothing goes in once the call is ending.
+   */
+  const relayOpenWork = useCallback(() => {
+    const live = session.current;
+    const threads = latest.current;
+    if (!live || !threads || reading.current.on || acting.current) return;
+    if (leaving.current || idle.current.asked) return;
+    // On a call-back, why she called goes in once the opening is voiced: it is the
+    // first thing they ask, and a quiet line would come too late
+    const rung = rang.current;
+    rang.current = false;
+    if (!rung && Date.now() - heard.current < CALL_RELAY.quietMs) return;
+    const open = openWork(threads).filter(
+      (item) => !told.current.has(item.key),
+    );
+    const first = open[0];
+    if (!first) return;
+    const due = open
+      .filter((item) => item.kind === first.kind)
+      .slice(0, CALL_RELAY.perTurn);
+    const lines = due.map((item) => item.line);
+
+    // Told as it goes out, even if Live refuses it: a refusal is tried again on the next
+    // call (unvoiced), never in a loop on this one
+    for (const item of due) {
+      told.current.add(item.key);
+      unvoiced.current.add(item.key);
+    }
+    readAloud();
+    onLine.current = due.map((item) => item.key);
+    // On the line before it goes out, so it runs there for the whole wait
+    showRelay((due.at(-1) ?? first).show);
+    // Appends go out in order, so the note is in her context before the first update
+    if (!relayNoted.current) {
+      relayNoted.current = true;
+      void live.append("instructions", RELAY_NOTE);
+    }
+    void live
+      .append(
+        "commentary",
+        lines.length === 1
+          ? lines.join("")
+          : `[${lines.length} updates.]\n\n${lines.join("\n\n")}`,
+      )
+      .then((delivered) => {
+        if (!delivered) {
+          doneReading();
+          return;
+        }
+        const ids = due.flatMap((item) => item.relayIds);
+        if (ids.length) return acceptThreadRelaysAction(ids).then(unwrapResult);
+      })
+      .catch((cause) =>
+        toast.add({
+          type: "error",
+          title: "Could not record relay delivery",
+          description: errorToString(cause),
+        }),
+      );
+  }, [readAloud, doneReading, showRelay]);
 
   /**
    * One timer; when it fires it wears the last wanted face, so a tool shorter
@@ -335,24 +472,22 @@ export function useThursday() {
     [restFace, wearFace],
   );
 
-  const onCall = status !== "idle" && status !== "connecting";
+  const onCall =
+    status !== "idle" && status !== "connecting" && status !== "ending";
 
   // Inbox, with or without a call. Revalidated on server events; polling is the safety net
-  const { data: tasks } = useServerRoute<Task[]>(queryKey.tasks, {
-    refreshInterval: TASK_POLL_FALLBACK_MS,
+  const { data: threads } = useServerRoute<Thread[]>(queryKey.threads, {
+    refreshInterval: THREAD_POLL_FALLBACK_MS,
   });
 
   // Server event stream (app/api/events): signals revalidate their key
-  const boot = useRef<string | null>(null);
   useAppEvent({
-    hello: (event) => {
+    hello: () => {
       // Sent on every connect, so this is also every reconnect: nothing that
-      // changed while the stream was down raised a signal anybody heard, and a
-      // changed `boot` means the server restarted on top of that
-      boot.current = event.boot;
+      // changed while the stream was down raised a signal anybody heard
       void revalidateAll();
     },
-    tasks: () => void revalidate(queryKey.tasks),
+    threads: () => void revalidate(queryKey.threads),
     memory: () => void revalidate(queryKey.memory),
     mcp: () => {
       void revalidate(queryKey.mcp);
@@ -368,51 +503,34 @@ export function useThursday() {
   // faces come from the bot list
   const { data: bots } = useServerRoute<Bot[]>(queryKey.bot);
   useEffect(() => {
-    if (tasks) botTasks.sync(tasks, bots);
-  }, [tasks, bots]);
-
-  // 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
+    if (threads) botThreads.sync(threads, bots);
+  }, [threads, bots]);
+
   useEffect(() => {
-    if (!tasks || !calling.current) return;
-    for (const task of tasks) {
-      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);
-      outbox.send({ line: relayLine(task), show: relayShow(task) });
-    }
-  }, [tasks, outbox, status]);
+    latest.current = threads;
+  }, [threads]);
 
-  // The user acted on a task on screen; the model may have just read that question and must not ask again
+  // The user acted on a thread on screen; she may have just read that question and must not ask again
   useEffect(
     () =>
       screenActs.subscribe((act) => {
         if (!calling.current) return;
-        outbox.send({
-          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 say anything more about it.`,
-        });
+        outbox.send(
+          act.kind === "answered"
+            ? `The user sent a message on screen to ${act.recipient ?? "the coordinator"} in thread "${act.label}" (${act.id})${act.replyTo ? `, replying to ${act.replyTo}` : ""}: ${act.answer}. It has reached that participant.`
+            : `The user stopped thread "${act.label}" on screen. It is no longer running.`,
+        );
       }),
     [outbox],
   );
 
   /** Closes the session and resets state. Turns were saved during the call. */
   const hangUp = useCallback(async () => {
+    if (ending.current) return;
+    ending.current = true;
+    if (leaving.current) clearInterval(leaving.current);
+    leaving.current = null;
+    attempt.current += 1;
     const live = session.current;
     const call = callId.current;
 
@@ -420,16 +538,16 @@ export function useThursday() {
     callId.current = null;
     calling.current = false;
     opening.current = false;
-    relayed.current.clear();
-    // unsent lines go: a question is relayed again next call, an ending is in her prompt
+    relayNoted.current = false;
+    rang.current = false;
+    // What she did not voice goes in again next call; unsent context goes with the session
+    for (const key of unvoiced.current) told.current.delete(key);
+    unvoiced.current.clear();
     outbox.close();
     outbox.clear();
-    // holds the closed session; the next call sets its own
-    resumeRelay.current = null;
     working.current?.abort();
     working.current = null;
-    mic.current.tool = false;
-    openMic();
+    doneReading();
     if (linger.current) clearTimeout(linger.current);
     // a pending face timer must not fire after the call
     restFace();
@@ -437,28 +555,38 @@ export function useThursday() {
     idle.current = { since: 0, asked: false, owed: null, grace: null };
     setIdleLeft(null);
     setSince(null);
-    setStatus("idle");
+    setStatus(live ? "ending" : "idle");
     setMessages([]);
     setTool(null);
-    // the room is not cleared: tasks outlive the call
-
-    // closing finalizes a mid-speech turn, so its save is queued first
-    live?.close();
-    if (call) void endCallAction(call);
+    setThinking(null);
+    if (thinkTail.current) clearTimeout(thinkTail.current);
+    thinkTail.current = null;
+    relayOpen.current = false;
+    // the room is not cleared: threads outlive the call
+
+    // Waits (bounded) for session.closed, which saves the last turns and says
+    // what was billed; the row is ended with that, after the saves it queued
+    await live?.close();
+    const close = finalized.current;
+    finalized.current = null;
+    ending.current = false;
+    setStatus("idle");
+    if (call) void endCallAction(call, close);
     // only when there was a line to close
     if (live && farewell.current) {
       farewell.current.currentTime = 0;
       void farewell.current.play().catch(() => {});
     }
-  }, [outbox, restFace, openMic]);
+  }, [outbox, restFace, doneReading, setThinking]);
 
   // Unmount during a call must release the mic and stop tools
   useEffect(() => {
     return () => {
-      session.current?.close();
+      attempt.current += 1;
+      void session.current?.close();
       session.current = null;
       // Closing only the session would leave the row live (thursday.query
-      // isAnyCallLive) and finished tasks unannounced (bot.runner); end the row too
+      // isAnyCallLive) and finished threads unannounced (bot.runner); end the row too
       const call = callId.current;
       callId.current = null;
       calling.current = false;
@@ -469,27 +597,48 @@ export function useThursday() {
       // clear timers so nothing sets state on an unmounted tree
       if (linger.current) clearTimeout(linger.current);
       if (faceIn.current) clearTimeout(faceIn.current);
-      if (mic.current.giveUp) clearTimeout(mic.current.giveUp);
+      if (reading.current.giveUp) clearTimeout(reading.current.giveUp);
+      if (thinkTail.current) clearTimeout(thinkTail.current);
       if (idle.current.grace) clearTimeout(idle.current.grace);
+      if (failedFor.current) clearTimeout(failedFor.current);
+      if (leaving.current) clearInterval(leaving.current);
     };
   }, []);
 
   /**
-   * Rewinds the idle clock. User activity also cancels a requested goodbye;
-   * agent activity does not, so the goodbye cannot cancel itself.
+   * The backend ended the call: hang up once her goodbye is over. She says it while
+   * the backend works, so it may be done already, still going, or yet to start;
+   * CALL_END bounds each case. The tool's own result always gets `quietMs` to go out.
    */
-  const stir = useCallback((who: "user" | "agent") => {
+  const leave = useCallback(() => {
+    if (leaving.current) return;
+    const asked = Date.now();
+    leaving.current = setInterval(() => {
+      const now = Date.now();
+      // A goodbye heard just before the backend ended the call counts as said
+      const said = voiced.current > asked - CALL_END.unsaidMs;
+      const over = said
+        ? now - Math.max(voiced.current, asked) >= CALL_END.quietMs
+        : now - asked >= CALL_END.unsaidMs;
+      if (over || now - asked >= CALL_END.maxMs) void hangUp();
+    }, 100);
+  }, [hangUp]);
+
+  /**
+   * Rewinds the idle clock. `user` is new words transcribed from them, first seen at
+   * `said`: an answer is owed from then, and a requested goodbye is off. Transcripts
+   * lag the audio, so her voice heard since `said` already answered them. `agent` is
+   * her voice or backend work, which settles what is owed but cannot cancel its own
+   * goodbye.
+   */
+  const stir = useCallback((who: "user" | "agent", said = 0) => {
     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 (voiced.current < said) idle.current.owed ??= now;
     if (idle.current.grace) clearTimeout(idle.current.grace);
     idle.current.grace = null;
     idle.current.asked = false;
@@ -503,7 +652,7 @@ export function useThursday() {
       const live = session.current;
       if (!live) return;
       const owed = idle.current.owed;
-      if (owed !== null && Date.now() - owed >= AGENT_SILENT_MS) {
+      if (owed !== null && Date.now() - owed >= CALL_IDLE.agentSilentMs) {
         // Nothing to say goodbye with; the model is what would have said it.
         toast.add({
           type: "error",
@@ -513,225 +662,300 @@ export function useThursday() {
         void hangUp();
         return;
       }
-      const left = IDLE_HANG_UP_MS - (Date.now() - idle.current.since);
+      const left = CALL_IDLE.hangUpMs - (Date.now() - idle.current.since);
       setIdleLeft(
-        left <= IDLE_WARN_MS && !idle.current.asked
+        left <= CALL_IDLE.warnMs && !idle.current.asked
           ? Math.max(0, Math.ceil(left / 1000))
           : null,
       );
       if (left > 0 || idle.current.asked) return;
 
       idle.current.asked = true;
-      live.say(IDLE_LINE);
-      idle.current.grace = setTimeout(() => void hangUp(), IDLE_GRACE_MS);
+      void live.append("instructions", IDLE_LINE);
+      idle.current.grace = setTimeout(() => void hangUp(), CALL_IDLE.graceMs);
     }, 1000);
     return () => clearInterval(tick);
   }, [onCall, stir, hangUp]);
 
-  const call = useCallback(async () => {
-    // Guard with a ref, not `status`: three entry points (face, wake word,
-    // hotkey) can fire in one frame and both see a stale "idle", opening two sessions
-    if (opening.current) return;
-    // with a line open this press hangs up; `calling` covers the gap before re-render
-    if (calling.current || status !== "idle") return hangUp();
-
-    setStatus("connecting");
-    // 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()));
-      callId.current = handshake.callId;
-
-      const stop = new AbortController();
-      working.current = stop;
-      const saving = { failures: 0 };
-
-      tap.current ??= createAudioTap();
-      // Inside the gesture: an AudioContext created elsewhere starts suspended.
-      // Calls from the wake word or a call-back have no gesture; armAudioUnlock handles those
-      armAudioUnlock(tap.current.open().context);
-      const chime = new Audio(CONNECTED_SOUND);
-      farewell.current ??= new Audio(HUNG_UP_SOUND);
-
-      // one turn per seq; the session reports turns one at a time
-      const turns: CallMessage[] = [];
-
-      const live = await openRealtimeSession({
-        provider: handshake.provider,
-        credential: handshake.credential,
-        setup: handshake.session,
-        audio: tap.current,
-        on: {
-          // the session calls tools; the page forwards them to the server
-          runTool: async (call) => {
-            // end_call is the page's only tool. Answer without awaiting: the socket
-            // goes down with the call, so this reply must go first
-            if (call.name === TOOL_NAMES.end_call) {
-              setTimeout(() => void hangUp(), HANG_UP_DELAY_MS);
-              return "Ending the call.";
-            }
-            showTool(call);
-            try {
-              return await runRemoteTool(handshake.callId, call, stop.signal);
-            } finally {
-              hideTool(call.name);
-            }
-          },
-          turn: (turn) => {
-            stir(turn.role === "user" ? "user" : "agent");
-            // tool turns are saved but not shown
-            if (turn.role !== "tool") {
-              turns[turn.seq] = {
-                id: turn.id,
-                role: turn.role,
-                text: turn.text,
-              };
-              // holes are turns whose text has not arrived
-              setMessages(turns.filter(Boolean).slice(-KEEP_MESSAGES));
-            }
-            if (turn.done) {
-              const { id, role, tool, text, seq } = turn;
-              persistTurn(
-                handshake.callId,
-                { id, role, tool, text, seq },
-                saving,
-              );
+  // The relay clock: open work goes in only while the line is quiet
+  useEffect(() => {
+    if (!onCall) return;
+    const tick = setInterval(relayOpenWork, 1000);
+    return () => clearInterval(tick);
+  }, [onCall, relayOpenWork]);
+
+  const call = useCallback(
+    async (placedBy?: "callBack") => {
+      // Compared exactly: a face tap hands its click event in here
+      const calledBack = placedBy === "callBack";
+      // Guard with a ref, not `status`: three entry points (face, wake word,
+      // hotkey) can fire in one frame and both see a stale "idle", opening two sessions
+      if (opening.current || ending.current) return;
+      // with a line open this press hangs up; `calling` covers the gap before re-render
+      if (calling.current || status !== "idle") return hangUp();
+
+      setStatus("connecting");
+      showFailed(false);
+      // from here on this is a call; the outbox holds updates until the session exists
+      opening.current = true;
+      calling.current = true;
+      finalized.current = null;
+      relayNoted.current = false;
+      outbox.clear();
+      attempt.current += 1;
+      const mine = attempt.current;
+      const current = () => calling.current && attempt.current === mine;
+      try {
+        // Inside the gesture, before anything awaits: an AudioContext created later
+        // starts suspended. Calls from the wake word or a call-back have no gesture;
+        // armAudioUnlock handles those
+        tap.current ??= createAudioTap();
+        armAudioUnlock(tap.current.open().context);
+        const chime = new Audio(CONNECTED_SOUND);
+        farewell.current ??= new Audio(HUNG_UP_SOUND);
+
+        const settings = thursdaySettings();
+        const stop = new AbortController();
+        working.current = stop;
+        const saving = { failures: 0 };
+        const thinkingSaves = { failures: 0 };
+        /** Filled in by the handshake, read by callbacks that only run after it. */
+        const line = { callId: "", opening: null as string | null };
+
+        // one turn per id; the session reports display groups one at a time
+        const turns = new Map<string, CallMessage & { seq: number }>();
+        /** When the page first saw each of the user's display groups. */
+        const userSaid = new Map<string, number>();
+
+        const live = await openLiveSession({
+          initialize: async (sdp) => {
+            const handshake = unwrapResult(
+              await openCallAction(settings, sdp, calledBack),
+            );
+            if (!current()) {
+              void endCallAction(handshake.callId);
+              throw new Error("The call closed during startup.");
             }
+            callId.current = handshake.callId;
+            line.callId = handshake.callId;
+            line.opening = handshake.opening;
+            return handshake.sdp;
           },
-          // session facts drive the face through showFace; the tool line is drawn by the tool itself
-          activity: (activity) => {
-            showFace(statusOf(activity));
-            if (activity.hearing) stir("user");
-            else if (activity.speaking || activity.tools.length) stir("agent");
-            // Tool mute is the live fact. Relay mute ends once playback has started and
-            // stopped: turn text is finalized before audio (realtime.session), so playback is what counts
-            mic.current.tool = activity.tools.length > 0;
-            if (mic.current.reading) {
-              if (activity.speaking) mic.current.spoke = true;
-              else if (mic.current.spoke) {
-                mic.current.reading = false;
-                // she has finished reading; whatever landed meanwhile goes now
-                resumeRelay.current?.();
+          audio: tap.current,
+          on: {
+            // the backend calls tools; the page forwards them to the server
+            runTool: async (call) => {
+              // end_call is the page's only tool. The line goes down once her
+              // goodbye is over (leave), so this reply reaches the model first
+              if (call.name === TOOL_NAMES.end_call) {
+                leave();
+                return "Ending the call.";
               }
-            }
-            if (!mic.current.reading) openMic();
-            else syncMic();
-          },
-          warn: (description) =>
-            toast.add({ type: "warning", title: "Call warning", description }),
-          failed: (description) => {
-            toast.add({ type: "error", title: "Call failed", description });
-            void hangUp();
+              showTool(call);
+              try {
+                return await runRemoteTool(line.callId, call, stop.signal);
+              } finally {
+                hideTool(call.id);
+              }
+            },
+            reasoning: (part) =>
+              persist(
+                thinkingSaves,
+                () =>
+                  saveThoughtAction(line.callId, {
+                    ...part,
+                    seq: Math.max(0, Math.round(part.seq)),
+                  }),
+                "The backend's thinking is not being saved",
+              ),
+            turn: (turn) => {
+              // New words, not a checkpoint of the same ones: a blank fragment is not words
+              const fresh =
+                turn.role !== "tool" &&
+                Boolean(turn.text.trim()) &&
+                turn.text !== turns.get(turn.id)?.text;
+              // New words from either side restart the relay's quiet clock
+              if (fresh) heard.current = Date.now();
+              // Her voice and backend work rewind the idle clock from activity, where an
+              // update she reads out is told apart; transcripts lag the audio and cannot
+              if (fresh && turn.role === "user") {
+                const said = userSaid.get(turn.id) ?? Date.now();
+                userSaid.set(turn.id, said);
+                stir("user", said);
+              }
+              // Tool turns are saved but not shown. Hanging up clears the screen
+              // before `close()` checkpoints open groups, so only the live call draws.
+              if (turn.role !== "tool" && callId.current === line.callId) {
+                turns.set(turn.id, {
+                  seq: turn.seq,
+                  id: turn.id,
+                  role: turn.role,
+                  text: turn.text,
+                });
+                setMessages(
+                  [...turns.values()]
+                    .sort((a, b) => a.seq - b.seq)
+                    .slice(-KEEP_MESSAGES),
+                );
+              }
+              if (turn.done) {
+                persist(saving, () =>
+                  saveTurnsAction(line.callId, [
+                    {
+                      id: turn.id,
+                      role: turn.role,
+                      tool: turn.tool,
+                      text: turn.text,
+                      // Live orders by audio milliseconds; the row keeps a whole number
+                      seq: Math.max(0, Math.round(turn.seq)),
+                      fragments: turn.fragments ?? null,
+                    },
+                  ]),
+                );
+              }
+            },
+            // session facts drive the face through showFace; the tool line is drawn by the tool itself
+            activity: (activity) => {
+              showFace(statusOf(activity));
+              const busy = activity.working || activity.tools.length > 0;
+              acting.current = busy;
+              // From the moment the backend picks the turn up until her first word
+              holdThinking(busy, activity.speaking);
+              if (activity.speaking) voiced.current = Date.now();
+              // Sound on the mic alone does not rewind the clock: a noisy room would
+              // keep a call open forever. Her words and backend work do, except an
+              // update she voices on her own: waiting results must not hold a call open.
+              if (
+                (activity.speaking && !reading.current.on) ||
+                activity.working ||
+                activity.tools.length
+              )
+                stir("agent");
+              // An update counts as voiced once her voice has started and stopped
+              if (reading.current.on) {
+                if (activity.speaking) reading.current.spoke = true;
+                else if (reading.current.spoke) doneReading();
+              }
+            },
+            finalized: (close) => {
+              finalized.current = close;
+            },
+            warn: (description) =>
+              toast.add({
+                type: "warning",
+                title: "Call warning",
+                description,
+              }),
+            failed: (description) => {
+              toast.add({ type: "error", title: "Call failed", description });
+              showFailed(true);
+              void hangUp();
+            },
           },
-        },
-      });
-
-      /**
-       * One line at a time. Three jobs landing together used to be three
-       * system items and three turns in a row, which the user hears
-       * as her talking to herself; the box stays closed while she reads one,
-       * and whatever arrived meanwhile goes out merged, as one thing to say.
-       */
-      const flush = (queued: Said[]) => {
-        if (!queued.length) return;
-        // not the user's turn while the model reads this
-        readAloud();
-        live.say(queued.length === 1 ? queued[0].line : mergedRelay(queued));
-        const last = queued.at(-1)?.show;
-        if (last) showRelay(last);
-        outbox.close();
-      };
-
-      resumeRelay.current = () => {
-        const held = outbox.clear();
-        outbox.open((one) => flush([one]));
-        flush(held);
-      };
-
-      // line open: flush held lines first
-      outbox.open((one) => flush([one]));
+        });
 
-      // An opening — a first call, or memory to tidy — makes the model speak first, on the same path as a relay
-      if (handshake.opening) {
-        readAloud();
-        live.say(handshake.opening);
+        if (!current()) {
+          // Hung up while the line was going up; hangUp already ended the row
+          await live.close();
+          return;
+        }
+
+        /** An opening that never landed leaves nothing to wait for. */
+        const unless = (delivered: boolean) => {
+          if (!delivered) doneReading();
+        };
+
+        session.current = live;
+        opening.current = false;
+        rang.current = calledBack;
+        // Context is not gated: held lines first, then each as it comes
+        outbox.open((text) => void live.append("thinking", text));
+        // The quiet clock starts with the line, so nothing is put to her the moment it opens
+        heard.current = Date.now();
+
+        if (line.opening) {
+          // The greeting goes first; open work waits until she has said it
+          readAloud();
+          void live.append("instructions", line.opening).then(unless);
+        }
+
+        wearFace("listening");
+        setSince(Date.now());
+        // a rejected chime is not worth a message
+        void chime.play().catch(() => {});
+      } catch (cause) {
+        // Hanging up while the line was going up is not a failure to report
+        if (current()) {
+          toast.add({
+            type: "error",
+            title: "Could not start the call",
+            description: errorToString(cause),
+          });
+          showFailed(true);
+        }
+        if (attempt.current !== mine) return;
+        // a call that never opened still has a row; close it
+        if (callId.current) void endCallAction(callId.current);
+        callId.current = null;
+        opening.current = false;
+        calling.current = false;
+        working.current = null;
+        outbox.clear();
+        setStatus("idle");
       }
-
-      session.current = live;
-      opening.current = false;
-      wearFace("listening");
-      setSince(Date.now());
-      // a rejected chime is not worth a message
-      void chime.play().catch(() => {});
-    } catch (cause) {
-      toast.add({
-        type: "error",
-        title: "Could not start the call",
-        description: errorToString(cause),
-      });
-      // a call that never opened still has a row; close it
-      if (callId.current) void endCallAction(callId.current);
-      callId.current = null;
-      opening.current = false;
-      calling.current = false;
-      outbox.clear();
-      // nothing was delivered; forget so the next call resends
-      relayed.current.clear();
-      setStatus("idle");
-    }
-  }, [
-    status,
-    hangUp,
-    showTool,
-    hideTool,
-    showRelay,
-    showFace,
-    wearFace,
-    stir,
-    outbox,
-    readAloud,
-    openMic,
-    syncMic,
-  ]);
+    },
+    [
+      status,
+      hangUp,
+      showTool,
+      hideTool,
+      showFace,
+      wearFace,
+      stir,
+      outbox,
+      readAloud,
+      doneReading,
+      holdThinking,
+      showFailed,
+      leave,
+    ],
+  );
 
   /**
-   * Call-back: opens a call when a task is waiting on the user and no line is
-   * open. Tried once per task (`woke`), or a failed open would redial forever;
-   * tasks present at app start count as already tried.
+   * Call-back: opens a call when a thread is waiting on the user and no line is
+   * open. Tried once per thread (`woke`), or a failed open would redial forever;
+   * threads present at app start count as already tried.
    */
   const callBack = useThursdayStore((state) => state.callBack);
   const woke = useRef<Set<string> | null>(null);
   useEffect(() => {
-    if (!tasks) return;
-    const wants = tasks.filter(
-      (task) =>
-        !task.seen &&
-        !task.ask?.auto &&
-        (asksSomething(task) ||
-          (callBack === "any" && task.status !== "running")),
+    if (!threads) return;
+    const wants = threads.filter(
+      (thread) =>
+        !thread.seen &&
+        !thread.ask?.auto &&
+        (asksSomething(thread) ||
+          (callBack === "any" && thread.status !== "running")),
     );
 
     if (!woke.current) {
-      woke.current = new Set(wants.map((task) => task.id));
+      woke.current = new Set(wants.map((thread) => thread.id));
       return;
     }
 
-    // forget tasks that stopped waiting; a later stop counts as fresh
-    const open = new Set(wants.map((task) => task.id));
+    // forget threads that stopped waiting; a later stop counts as fresh
+    const open = new Set(wants.map((thread) => thread.id));
     for (const id of woke.current) {
       if (!open.has(id)) woke.current.delete(id);
     }
 
     if (callBack === "off" || status !== "idle") return;
-    const fresh = wants.filter((task) => !woke.current?.has(task.id));
+    const fresh = wants.filter((thread) => !woke.current?.has(thread.id));
     if (!fresh.length) return;
 
-    for (const task of wants) woke.current.add(task.id);
-    void call();
-  }, [tasks, callBack, status, call]);
+    for (const thread of wants) woke.current.add(thread.id);
+    void call("callBack");
+  }, [threads, callBack, status, call]);
 
   /** Read by the face once per animation frame, outside React state. */
   const getSpectrum = useCallback(() => tap.current?.read() ?? EMPTY_BANDS, []);
@@ -748,12 +972,15 @@ export function useThursday() {
     enabled: status === "idle" && wake.enabled && !wakeBlocked,
     phrases: [wake.phrase],
     onWake: () => void call(),
-    onError: () => setWakeBlocked(true),
+    onError: (reason) => {
+      setWakeBlocked(true);
+      toast.add({ type: "error", title: "Wake word off", description: reason });
+    },
   });
 
   // Hotkey presses `call` like the face tap, so it hangs up during a call; disabled while the line goes up or down
   const hotkey = useThursdayStore((state) => state.hotkey);
-  const busy = status === "connecting";
+  const busy = status === "connecting" || status === "ending";
   useHotkey({
     enabled: hotkey.enabled && !busy,
     combo: hotkey.enabled && isCombo(hotkey.combo) ? hotkey.combo : null,
@@ -762,12 +989,14 @@ export function useThursday() {
 
   return {
     status,
+    /** A call just failed to open or dropped; true for a few seconds after. */
+    failed,
     messages,
     tool,
+    /** When the backend picked the turn up (ms); null when it is not working. */
+    thinkingSince,
     /** Seconds until idle hang-up; null outside the warning window. */
     idleLeft,
-    /** Mic muted: a tool is running or a relay is being read. */
-    micOff,
     /** When the line opened (ms); null without a call. */
     since,
     call,
@@ -780,11 +1009,7 @@ export function useThursday() {
   };
 }
 
-const EMPTY_BANDS = new Array<number>(MARK_BANDS).fill(0);
-
-/** Relay dedup key: task id plus its last state change. */
-const relayKey = (task: Task) =>
-  `${task.id}@${toDate(task.updatedAt).getTime()}`;
+const EMPTY_BANDS = new Array<number>(SPECTRUM_BANDS).fill(0);
 
 /**
  * Calls opened without a gesture (wake word, call-back) get a suspended
@@ -816,34 +1041,32 @@ function armAudioUnlock(context: AudioContext) {
   });
 }
 
-/** Tools win over speech; delegate gets its own face. */
-function statusOf(activity: RealtimeActivity): LiveStatus {
-  if (activity.tools.length) {
+/** Voice wins over work; delegate gets its own face. */
+function statusOf(activity: LiveActivity): LiveStatus {
+  if (activity.speaking) return "speaking";
+  if (activity.working || activity.tools.length) {
     return activity.tools.includes(TOOL_NAMES.delegate)
       ? "delegating"
       : "working";
   }
-  return activity.speaking ? "speaking" : "listening";
+  return "listening";
 }
 
-/**
- * Fire-and-forget save: one toast after SAVE_FAILURE_LIMIT failures, then
- * silence.
- */
-function persistTurn(
-  callId: string,
-  turn: CallTurn,
+/** Fire-and-forget save; after SAVE_FAILURE_LIMIT failures of this kind it stops and says so once. */
+function persist(
   saving: { failures: number },
+  save: () => Promise<Result<unknown>>,
+  stopped = "This call is not being saved",
 ) {
   if (saving.failures >= SAVE_FAILURE_LIMIT) return;
-  void saveTurnsAction(callId, [turn])
+  void save()
     .then((result) => unwrapResult(result))
     .catch((cause) => {
       saving.failures += 1;
       if (saving.failures !== SAVE_FAILURE_LIMIT) return;
       toast.add({
         type: "warning",
-        title: "This call is not being saved",
+        title: stopped,
         description: errorToString(cause),
       });
     });
@@ -853,58 +1076,110 @@ function persistTurn(
  * 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" && !isAppStop(task.ask);
-}
+const asksSomething = (thread: Thread) => thread.room.questions.length > 0;
+
+/** One piece of background work waiting on the user, as the relay clock puts it to her. */
+type OpenWork = {
+  key: string;
+  /** What it is, so one append holds one kind. */
+  kind: "question" | "ending" | "progress";
+  /** The relay text. */
+  line: string;
+  /** Relay rows it covers, accepted once it lands. */
+  relayIds: number[];
+  /** The same item on the activity line, so the user sees where her words came from. */
+  show: ActivityLine;
+};
 
-/**
- * Sent as a system entry (realtime.driver say); the first sentence names
- * sender and recipient or the model answers it as user speech.
- */
-function relayLine(task: Task) {
-  // 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 stop is told, not read as a question
-      const options = task.ask?.options ?? [];
-      const said = task.ask?.question ?? task.outcome ?? "";
-      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.`;
-    }
-    case "failed":
-      return `${from} It could not finish: ${task.outcome ?? ""}`;
-    default:
-      return `${from} Done. Its answer: ${task.outcome ?? ""}`;
-  }
-}
+const OPEN_RANK = {
+  question: 0,
+  stopped: 1,
+  done: 2,
+  progress: 3,
+} as const;
 
 /**
- * Lines that piled up while she was reading, as one system entry. The header
- * is what stops it becoming one turn per job: they arrived together and the
- * user has heard none of them.
+ * Everything in the inbox still waiting on the user, most pressing first:
+ * questions, then jobs stopped or finished and not yet seen, then
+ * progress from jobs still running. Sent as commentary; the bracket carries
+ * facts only — who, which thread, where an answer goes — because the backend
+ * reads relays too and routes answers by them.
  */
-function mergedRelay(queued: Said[]) {
-  return `[${queued.length} jobs came back at once — not the user speaking; they have heard none of this. Tell them in one turn, not ${queued.length}.]
+function openWork(threads: Thread[]): OpenWork[] {
+  const items: (OpenWork & { rank: number })[] = [];
+  for (const thread of threads) {
+    const { relays, questions } = thread.room;
+    const changed = toDate(thread.updatedAt).getTime();
+    const bracket = (from: string, kind: string, tail = "") =>
+      `[${from} → Thursday, thread "${thread.label}" (${thread.id}), ${kind}.${tail}]`;
+    const show = (bot: string, line: string): ActivityLine => ({
+      kind: "relay",
+      name: thread.label,
+      line,
+      done: true,
+      bot,
+    });
 
-${queued.map((one) => one.line).join("\n\n")}`;
-}
+    for (const question of questions) {
+      const options = question.options?.length
+        ? ` Options: ${question.options.join(" / ")}.`
+        : "";
+      items.push({
+        rank: OPEN_RANK.question,
+        key: `question:${question.id}`,
+        kind: "question",
+        line: `${bracket(question.bot, "question", ` Its answer goes to thread ${thread.id}, recipient ${question.bot}, replyTo ${question.id}.`)}\n${question.text}${options}`,
+        relayIds: relays
+          .filter((relay) => relay.messageId === question.id)
+          .map((relay) => relay.id),
+        show: show(question.bot, `${question.bot}: question`),
+      });
+    }
 
-/** The same relay on the activity line, so the user sees where the model's line came from. */
-function relayShow(task: Task): ToolRun {
-  const line =
-    task.status === "waiting"
-      ? isAppStop(task.ask)
-        ? `${task.bot} stopped`
-        : `${task.bot} is asking`
-      : task.status === "failed"
-        ? `${task.bot} could not finish`
-        : `Answer from ${task.bot}`;
-  return { kind: "relay", name: task.label, line, done: true, bot: task.bot };
-}
+    // Relay rows that belong to no open question
+    const loose = relays.filter(
+      (relay) => !questions.some((question) => question.id === relay.messageId),
+    );
+    // A cancel is the user's own and already seen; nothing about it is news
+    const ended = thread.status === "done";
+    // A stop the app picks back up by itself is not news: it runs again in a moment
+    const stopped =
+      thread.status === "waiting" && isAppStop(thread.ask) && !thread.ask?.auto;
+
+    if (ended || stopped) {
+      if (thread.seen) continue;
+      const kind = stopped ? "stopped" : "done";
+      const said =
+        kind === "stopped"
+          ? `It stopped before finishing. Where it got to: ${thread.ask?.question ?? thread.outcome ?? ""}`
+          : `Done. Its answer: ${thread.outcome ?? ""}`;
+      items.push({
+        rank: OPEN_RANK[kind],
+        key: `${kind}:${thread.id}@${changed}`,
+        kind: "ending",
+        line: `${bracket(thread.bot, kind)}\n${said}`,
+        // Its ending says what its progress messages said
+        relayIds: loose.map((relay) => relay.id),
+        show: show(
+          thread.bot,
+          kind === "stopped"
+            ? `${thread.bot} stopped`
+            : `Answer from ${thread.bot}`,
+        ),
+      });
+      continue;
+    }
 
-export type { CallMessage, CallStatus };
+    for (const relay of loose) {
+      items.push({
+        rank: OPEN_RANK.progress,
+        key: `progress:${relay.id}`,
+        kind: "progress",
+        line: `${bracket(relay.bot, relay.kind)}\n${relay.text}`,
+        relayIds: [relay.id],
+        show: show(relay.bot, `${relay.bot}: ${relay.kind}`),
+      });
+    }
+  }
+  return items.sort((a, b) => a.rank - b.rank);
+}