thursday-agent 0.5.0 → 0.7.0

package/features/thursday/use-thursday.ts

@@ -1,60 +1,61 @@
 "use client";
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, 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_BACK, 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 { FACE_WORD_MAX, undrawable } from "./ascii.const";
 import {
   endCallAction,
   openCallAction,
+  saveThoughtAction,
   saveTurnsAction,
 } from "./thursday.action";
 import type {
+  CallBack,
   CallMessage,
   CallStatus,
-  CallTurn,
+  FaceWord,
   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 and puts a word on the face.
  */
 
-/** 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 +70,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,127 +89,153 @@ 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.
- */
-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;
-
-/** 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).
+ * 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 AGENT_SILENT_MS = 30_000;
+const FAILED_FACE_MS = 6000;
 
-const IDLE_LINE =
-  "The user has said nothing for a minute. Say a one-line goodbye, then call end_call.";
+/** Scrollback for the side-by-side layout; the call view shows at most three. */
+const KEEP_MESSAGES = 24;
 
-/**
- * Upper bound on the mic staying muted for a relayed line the model never
- * voices (the response can be rejected).
- */
-const RELAY_MIC_MS = 15_000;
+/** Safety net only; the event stream revalidates threads as they change. */
+const THREAD_POLL_FALLBACK_MS = 30_000;
 
-/** A line queued for the model. */
-type Said = {
-  line: string;
-  /** Shown on the activity line when the line is sent. */
-  show?: ToolRun;
-};
+/** Failed saves of one kind before the call stops saving that kind and says so, once. */
+const SAVE_FAILURE_LIMIT = 3;
 
 /**
- * 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;
 };
 
+/** A call-back ringing, as the screen names it. */
+export type Ringing = {
+  /** The bot whose work rang: the one asking, else the thread's own. */
+  bot: string;
+  kind: "question" | "done" | "stopped";
+  label: string;
+  /** Other threads ringing with it. */
+  more: number;
+};
+
+/**
+ * Why a call ended without the user hanging up: the line was quiet (CALL_IDLE),
+ * she hung up (`end_call`), Live closed the session, or the connection dropped.
+ */
+export type CallEnd = "quiet" | "hungUp" | "closed" | "dropped";
+
 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);
+  /** Why the last call ended, when the user did not end it; cleared by the next call. */
+  const [ended, setEnded] = useState<CallEnd | null>(null);
+  /** When the backend picked this turn up (ms); the activity line counts from it. */
+  const [thinkingSince, setThinkingSince] = useState<number | null>(null);
+  /** The title of the backend's latest reasoning summary in this stretch of work. */
+  const [thinkingTitle, setThinkingTitle] = useState<string | null>(null);
+  /** The word `emote` last put on the face. */
+  const [faceWord, setFaceWord] = useState<FaceWord | 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 });
-  /**
-   * 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, owed: null, grace: 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);
+  /** When the line last had new words from the user, her voice or backend work: the idle clock. */
+  const stirred = useRef(0);
   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 told = useRef(new Set<string>());
+  /**
+   * The call-back rings only for threads that changed after this: the last call's
+   * end, the last ring, or the page opening.
    */
-  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 ringAfter = useRef(Date.now());
+  /** The threads a call-back is ringing for, until it is answered, declined or rings out. */
+  const [ringingFor, setRingingFor] = useState<string[]>([]);
+  const isRinging = ringingFor.length > 0;
   /**
-   * 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[]>([]);
+  /** When her voice was last heard, for letting a goodbye finish (CALL_END). */
+  const voiced = useRef(0);
+  /** 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);
   /**
-   * Sends what piled up while she was reading the last line, as one line. Set
-   * for the length of a session; null between calls.
+   * 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 resumeRelay = useRef<(() => void) | null>(null);
+  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 +244,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 +263,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 +287,141 @@ 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,
+    );
+  }, []);
+
+  /** An update is on the wire: nothing else goes in until she has voiced it. */
+  const readAloud = useCallback(() => {
+    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);
+    // a stretch of work that starts or ends has not said what it is about yet
+    setThinkingTitle(null);
   }, []);
 
-  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]);
+  /**
+   * 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],
+  );
 
-  /** A relayed line is on the wire; the mic stays muted until it is read. */
-  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]);
+  /**
+   * 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) 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);
+    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 +483,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,97 +514,93 @@ 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 () => {
-    const live = session.current;
-    const call = callId.current;
-
-    session.current = null;
-    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
-    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();
-    if (linger.current) clearTimeout(linger.current);
-    // 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, owed: null, grace: null };
-    setIdleLeft(null);
-    setSince(null);
-    setStatus("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);
-    // only when there was a line to close
-    if (live && farewell.current) {
-      farewell.current.currentTime = 0;
-      void farewell.current.play().catch(() => {});
-    }
-  }, [outbox, restFace, openMic]);
+  /** Closes the session and resets state. Turns were saved during the call. `why` is null when the user hung up. */
+  const hangUp = useCallback(
+    async (why: CallEnd | null = null) => {
+      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;
+
+      session.current = null;
+      callId.current = null;
+      calling.current = false;
+      opening.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();
+      working.current?.abort();
+      working.current = null;
+      doneReading();
+      if (linger.current) clearTimeout(linger.current);
+      // a pending face timer must not fire after the call
+      restFace();
+      // What came up on this call was this call's to tell; the call-back rings only for what comes after
+      ringAfter.current = Date.now();
+      setIdleLeft(null);
+      setSince(null);
+      setStatus(live ? "ending" : "idle");
+      setMessages([]);
+      setTool(null);
+      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 (live) setEnded(why);
+      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, 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,217 +611,278 @@ 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 (idle.current.grace) clearTimeout(idle.current.grace);
+      if (reading.current.giveUp) clearTimeout(reading.current.giveUp);
+      if (thinkTail.current) clearTimeout(thinkTail.current);
+      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 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;
-  }, []);
-
-  // Idle clock: shows the countdown, then asks for a goodbye and grants a grace period
+  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("hungUp");
+    }, 100);
+  }, [hangUp]);
+
+  // Idle clock: shows the countdown, then hangs up. The page ends a quiet line itself;
+  // a goodbye would leave the ending to the model
   useEffect(() => {
     if (!onCall) return;
-    stir("agent");
+    stirred.current = Date.now();
     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);
+      if (!session.current) return;
+      const left = CALL_IDLE.hangUpMs - (Date.now() - stirred.current);
       setIdleLeft(
-        left <= IDLE_WARN_MS && !idle.current.asked
-          ? Math.max(0, Math.ceil(left / 1000))
-          : null,
+        left <= CALL_IDLE.warnMs ? 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);
+      if (left <= 0) void hangUp("quiet");
     }, 1000);
     return () => clearInterval(tick);
-  }, [onCall, stir, hangUp]);
+  }, [onCall, hangUp]);
+
+  // 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 () => {
+    // Every way in answers a ringing call-back: the face, the wake word, the hotkey
+    const calledBack = isRinging;
     // 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;
+    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();
+    setRingingFor([]);
 
     setStatus("connecting");
-    // from here on this is a call; the outbox holds lines until the session exists
+    setEnded(null);
+    showFailed(false);
+    // from here on this is a call; the outbox holds updates until the session exists
     opening.current = true;
     calling.current = true;
-    placedAt.current = Date.now();
+    finalized.current = null;
     outbox.clear();
+    attempt.current += 1;
+    const mine = attempt.current;
+    const current = () => calling.current && attempt.current === mine;
     try {
-      const handshake = unwrapResult(await openCallAction(thursdaySettings()));
-      callId.current = handshake.callId;
-
-      const stop = new AbortController();
-      working.current = stop;
-      const saving = { failures: 0 };
-
+      // 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();
-      // 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,
+      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 }>();
+
+      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;
+        },
         audio: tap.current,
         on: {
-          // the session calls tools; the page forwards them to the server
+          // the backend 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
+            // end_call and emote are the page's own tools. The line goes down once
+            // her goodbye is over (leave), so this reply reaches the model first
             if (call.name === TOOL_NAMES.end_call) {
-              setTimeout(() => void hangUp(), HANG_UP_DELAY_MS);
+              leave();
               return "Ending the call.";
             }
+            // the face draws the word; nothing runs anywhere else
+            if (call.name === TOOL_NAMES.emote) {
+              const { word, reply } = readFaceWord(call.arguments);
+              if (word) setFaceWord({ text: word, at: Date.now() });
+              return reply;
+            }
             showTool(call);
             try {
-              return await runRemoteTool(handshake.callId, call, stop.signal);
+              return await runRemoteTool(line.callId, call, stop.signal);
             } finally {
-              hideTool(call.name);
+              hideTool(call.id);
             }
           },
+          reasoning: (part) => {
+            // A summary part opens with its title in bold; the activity line says what the work is about
+            const title = /^\s*\*\*(.+?)\*\*/.exec(part.text)?.[1]?.trim();
+            if (title) setThinkingTitle(title);
+            persist(
+              thinkingSaves,
+              () =>
+                saveThoughtAction(line.callId, {
+                  ...part,
+                  seq: Math.max(0, Math.round(part.seq)),
+                }),
+              "The backend's thinking is not being saved",
+            );
+          },
           turn: (turn) => {
-            stir(turn.role === "user" ? "user" : "agent");
-            // tool turns are saved but not shown
-            if (turn.role !== "tool") {
-              turns[turn.seq] = {
+            // New words, not a checkpoint of the same ones. A cough or a sigh is not words:
+            // it neither holds the line open nor holds an update back
+            const words = turn.role === "tool" ? "" : spokenWords(turn.text);
+            const fresh =
+              Boolean(words) &&
+              words !== spokenWords(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") stirred.current = Date.now();
+            // 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,
-              };
-              // holes are turns whose text has not arrived
-              setMessages(turns.filter(Boolean).slice(-KEEP_MESSAGES));
+              });
+              setMessages(
+                [...turns.values()]
+                  .sort((a, b) => a.seq - b.seq)
+                  .slice(-KEEP_MESSAGES),
+              );
             }
             if (turn.done) {
-              const { id, role, tool, text, seq } = turn;
-              persistTurn(
-                handshake.callId,
-                { id, role, tool, text, seq },
-                saving,
+              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));
-            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?.();
-              }
+            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
+            )
+              stirred.current = Date.now();
+            // 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();
             }
-            if (!mic.current.reading) openMic();
-            else syncMic();
+          },
+          finalized: (close) => {
+            finalized.current = close;
           },
           warn: (description) =>
-            toast.add({ type: "warning", title: "Call warning", description }),
+            toast.add({
+              type: "warning",
+              title: "Call warning",
+              description,
+            }),
           failed: (description) => {
             toast.add({ type: "error", title: "Call failed", description });
-            void hangUp();
+            showFailed(true);
+            // Live says session.closed (finalized) when it closes the call itself
+            void hangUp(finalized.current ? "closed" : "dropped");
           },
         },
       });
 
-      /**
-       * 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();
-      };
+      if (!current()) {
+        // Hung up while the line was going up; hangUp already ended the row
+        await live.close();
+        return;
+      }
 
-      resumeRelay.current = () => {
-        const held = outbox.clear();
-        outbox.open((one) => flush([one]));
-        flush(held);
+      /** An opening that never landed leaves nothing to wait for. */
+      const unless = (delivered: boolean) => {
+        if (!delivered) doneReading();
       };
 
-      // 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) {
+      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();
-        live.say(handshake.opening);
+        void live.append("instructions", line.opening).then(unless);
       }
 
-      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),
-      });
+      // 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();
-      // nothing was delivered; forget so the next call resends
-      relayed.current.clear();
       setStatus("idle");
     }
   }, [
@@ -687,51 +890,87 @@ export function useThursday() {
     hangUp,
     showTool,
     hideTool,
-    showRelay,
     showFace,
     wearFace,
-    stir,
     outbox,
     readAloud,
-    openMic,
-    syncMic,
+    doneReading,
+    holdThinking,
+    showFailed,
+    leave,
+    isRinging,
   ]);
 
   /**
-   * 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: rings when a thread is waiting on the user and no line is open,
+   * only for threads that changed after `ringAfter`. What came up during a call
+   * was that call's to tell, and the next call tells what it left unsaid. Ringing
+   * never opens the line; answering does (`call`). A thread handled meanwhile, on
+   * screen or by the setting going off, stops ringing for itself.
    */
   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 wanted = new Set(
+      threads
+        .filter((thread) => ringsFor(thread, callBack))
+        .map((thread) => thread.id),
     );
+    setRingingFor((ids) =>
+      ids.every((id) => wanted.has(id))
+        ? ids
+        : ids.filter((id) => wanted.has(id)),
+    );
+    if (status !== "idle") return;
+    const after = ringAfter.current;
+    const fresh = threads.filter(
+      (thread) =>
+        wanted.has(thread.id) && toDate(thread.updatedAt).getTime() > after,
+    );
+    if (!fresh.length) return;
 
-    if (!woke.current) {
-      woke.current = new Set(wants.map((task) => task.id));
-      return;
-    }
-
-    // forget tasks that stopped waiting; a later stop counts as fresh
-    const open = new Set(wants.map((task) => task.id));
-    for (const id of woke.current) {
-      if (!open.has(id)) woke.current.delete(id);
-    }
+    ringAfter.current = Date.now();
+    setRingingFor((ids) => [
+      ...ids,
+      ...fresh.map((thread) => thread.id).filter((id) => !ids.includes(id)),
+    ]);
+  }, [threads, callBack, status]);
 
-    if (callBack === "off" || status !== "idle") return;
-    const fresh = wants.filter((task) => !woke.current?.has(task.id));
-    if (!fresh.length) return;
+  // While ringing: it stops by itself after CALL_BACK.ringMs, and Esc declines.
+  // A thread added to a ring already going does not restart the clock
+  useEffect(() => {
+    if (!isRinging) return;
+    const out = setTimeout(() => setRingingFor([]), CALL_BACK.ringMs);
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === "Escape" && !event.defaultPrevented) setRingingFor([]);
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => {
+      clearTimeout(out);
+      window.removeEventListener("keydown", onKeyDown);
+    };
+  }, [isRinging]);
 
-    for (const task of wants) woke.current.add(task.id);
-    void call();
-  }, [tasks, callBack, status, call]);
+  const decline = useCallback(() => setRingingFor([]), []);
+  /** What the ringing screen names: the first thread that rang, and how many rang with it. */
+  const ringing = useMemo((): Ringing | null => {
+    const rung = ringingFor.flatMap(
+      (id) => threads?.find((thread) => thread.id === id) ?? [],
+    );
+    const first = rung[0];
+    if (!first) return null;
+    const question = first.room.questions[0];
+    return {
+      bot: question?.bot ?? first.bot,
+      kind: question
+        ? "question"
+        : first.status === "done"
+          ? "done"
+          : "stopped",
+      label: first.label,
+      more: rung.length - 1,
+    };
+  }, [ringingFor, threads]);
 
   /** Read by the face once per animation frame, outside React state. */
   const getSpectrum = useCallback(() => tap.current?.read() ?? EMPTY_BANDS, []);
@@ -748,12 +987,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,15 +1004,27 @@ export function useThursday() {
 
   return {
     status,
+    /** A call just failed to open or dropped; true for a few seconds after. */
+    failed,
     messages,
     tool,
+    /** Why the last call ended, when the user did not end it; null during a call. */
+    ended,
+    /** When the backend picked the turn up (ms); null when it is not working. */
+    thinkingSince,
+    /** What the backend's latest reasoning summary says it is doing; null before one arrives. */
+    thinkingTitle,
+    /** The word `emote` last put on the face; null before one. */
+    faceWord,
     /** 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,
+    /** A call-back ringing; null when none is. Any way of placing a call answers it. */
+    ringing,
+    /** Stops the ringing without answering. */
+    decline,
     getSpectrum,
     getMicSpectrum,
     /** null when the tap is the only entry point. */
@@ -780,11 +1034,37 @@ export function useThursday() {
   };
 }
 
-const EMPTY_BANDS = new Array<number>(MARK_BANDS).fill(0);
+const EMPTY_BANDS = new Array<number>(SPECTRUM_BANDS).fill(0);
 
-/** Relay dedup key: task id plus its last state change. */
-const relayKey = (task: Task) =>
-  `${task.id}@${toDate(task.updatedAt).getTime()}`;
+/** What `emote` asked the face to show, and the line the model reads back; `word` is null when nothing is shown. */
+function readFaceWord(args: string): { word: string | null; reply: string } {
+  let text = "";
+  try {
+    const parsed: unknown = JSON.parse(args);
+    if (parsed && typeof parsed === "object" && "text" in parsed) {
+      text = String(parsed.text ?? "").trim();
+    }
+  } catch {
+    text = "";
+  }
+  const length = Array.from(text).length;
+  if (!length)
+    return { word: null, reply: "Nothing was shown: text is empty." };
+  if (length > FACE_WORD_MAX) {
+    return {
+      word: null,
+      reply: `Too long: ${length} characters, ${FACE_WORD_MAX} at most. Nothing was shown.`,
+    };
+  }
+  const bad = undrawable(text);
+  if (bad) {
+    return {
+      word: null,
+      reply: `Cannot draw "${bad}"; use only the characters \`text\` lists. Nothing was shown.`,
+    };
+  }
+  return { word: text.toUpperCase(), reply: "Shown." };
+}
 
 /**
  * Calls opened without a gesture (wake word, call-back) get a suspended
@@ -816,95 +1096,159 @@ 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.
+ * The words in a transcript, without the sounds Live writes in brackets ("[clear throat]",
+ * "[sigh]"); a bracket may close in the next group ("] okay"). Empty when nothing was said.
  */
-function persistTurn(
-  callId: string,
-  turn: CallTurn,
+function spokenWords(text: string) {
+  const words = text.replace(/\[[^\]]*\]?|\]/g, "").trim();
+  return /[\p{L}\p{N}]/u.test(words) ? words : "";
+}
+
+/** 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),
       });
     });
 }
 
 /**
- * Waiting on a real question. A job the app stopped waits in the inbox
- * instead of ringing.
+ * Whether a thread is one the call-back rings for: a real question, or with
+ * "any" every ending. A job the app stops and picks up by itself never rings.
  */
-function asksSomething(task: Task) {
-  return task.status === "waiting" && !isAppStop(task.ask);
-}
+const ringsFor = (thread: Thread, callBack: CallBack) =>
+  callBack !== "off" &&
+  !thread.seen &&
+  !thread.ask?.auto &&
+  (thread.room.questions.length > 0 ||
+    (callBack === "any" && thread.status !== "running"));
+
+/** 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);
+}