thursday-agent 0.6.0 → 0.7.0

package/features/thursday/use-thursday.ts

@@ -1,10 +1,10 @@
 "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_END, CALL_IDLE, CALL_RELAY } from "@/config";
+import { CALL_BACK, CALL_END, CALL_IDLE, CALL_RELAY } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { acceptThreadRelaysAction } from "@/features/bot/bot.action";
 import { type Bot, isAppStop, type Thread } from "@/features/bot/bot.schema";
@@ -33,20 +33,27 @@ import {
 } from "@/lib/protocol/use-server-route";
 import { createOutbox, type Outbox } from "@/lib/queue";
 import { errorToString } from "@/lib/utils";
+import { FACE_WORD_MAX, undrawable } from "./ascii.const";
 import {
   endCallAction,
   openCallAction,
   saveThoughtAction,
   saveTurnsAction,
 } from "./thursday.action";
-import type { CallMessage, CallStatus, LiveStatus } from "./thursday.schema";
+import type {
+  CallBack,
+  CallMessage,
+  CallStatus,
+  FaceWord,
+  LiveStatus,
+} from "./thursday.schema";
 import { thursdaySettings, useThursdayStore } from "./thursday.store";
 import { toolBot, toolLine } from "./tool-line";
 
 /**
  * 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.
+ * (tool-call); the page itself only hangs up and puts a word on the face.
  */
 
 /** Plays when the line opens. */
@@ -97,16 +104,6 @@ const THREAD_POLL_FALLBACK_MS = 30_000;
 /** Failed saves of one kind before the call stops saving that kind and says so, once. */
 const SAVE_FAILURE_LIMIT = 3;
 
-/**
- * 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_NOTE =
-  "An update from background work follows. If you have already told the user what it says, it need not be said again.";
-
-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.`;
-
 /**
  * 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
@@ -124,6 +121,22 @@ export type ActivityLine = {
   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<LiveSession | null>(null);
   // created on the first call: `new Audio()` cannot run during SSR
@@ -148,8 +161,14 @@ export function useThursday() {
   const [since, setSince] = useState<number | null>(null);
   /** 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);
@@ -164,16 +183,8 @@ export function useThursday() {
   }>({ 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).
-   */
-  const idle = useRef<{
-    since: number;
-    asked: boolean;
-    owed: number | null;
-    grace: ReturnType<typeof setTimeout> | null;
-  }>({ since: 0, asked: false, owed: null, grace: 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);
@@ -188,6 +199,14 @@ export function useThursday() {
    * 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 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;
   /**
    * 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
@@ -196,13 +215,8 @@ export function useThursday() {
   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), and for
-   * telling words she already answered from words still owed an answer.
-   */
+  /** When her voice was last heard, for letting a goodbye finish (CALL_END). */
   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. */
@@ -307,6 +321,8 @@ export function useThursday() {
   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);
   }, []);
 
   /**
@@ -357,7 +373,7 @@ export function useThursday() {
     const live = session.current;
     const threads = latest.current;
     if (!live || !threads || reading.current.on || acting.current) return;
-    if (leaving.current || idle.current.asked) 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;
@@ -383,11 +399,6 @@ export function useThursday() {
     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",
@@ -524,60 +535,63 @@ export function useThursday() {
     [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;
-
-    session.current = null;
-    callId.current = null;
-    calling.current = false;
-    opening.current = false;
-    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();
-    working.current?.abort();
-    working.current = null;
-    doneReading();
-    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(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
+  /** 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;
 
-    // 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, doneReading, setThinking]);
+      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(() => {
@@ -599,7 +613,6 @@ export function useThursday() {
       if (faceIn.current) clearTimeout(faceIn.current);
       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);
     };
@@ -620,62 +633,25 @@ export function useThursday() {
       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();
+      if (over || now - asked >= CALL_END.maxMs) void hangUp("hungUp");
     }, 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") {
-      idle.current.owed = null;
-      return;
-    }
-    if (voiced.current < said) 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
+  // 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 >= CALL_IDLE.agentSilentMs) {
-        // 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 = CALL_IDLE.hangUpMs - (Date.now() - idle.current.since);
+      if (!session.current) return;
+      const left = CALL_IDLE.hangUpMs - (Date.now() - stirred.current);
       setIdleLeft(
-        left <= CALL_IDLE.warnMs && !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;
-      void live.append("instructions", IDLE_LINE);
-      idle.current.grace = setTimeout(() => void hangUp(), CALL_IDLE.graceMs);
+      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(() => {
@@ -684,278 +660,317 @@ export function useThursday() {
     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),
+  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 || 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");
+    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;
+    finalized.current = null;
+    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 }>();
+
+      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 backend calls tools; the page forwards them to the server
+          runTool: async (call) => {
+            // 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) {
+              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(line.callId, call, stop.signal);
+            } finally {
+              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",
             );
-            if (!current()) {
-              void endCallAction(handshake.callId);
-              throw new Error("The call closed during startup.");
+          },
+          turn: (turn) => {
+            // 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,
+              });
+              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
+            )
+              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();
             }
-            callId.current = handshake.callId;
-            line.callId = handshake.callId;
-            line.opening = handshake.opening;
-            return handshake.sdp;
           },
-          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.";
-              }
-              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();
-            },
+          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);
+            // Live says session.closed (finalized) when it closes the call itself
+            void hangUp(finalized.current ? "closed" : "dropped");
+          },
+        },
+      });
 
-        if (!current()) {
-          // Hung up while the line was going up; hangUp already ended the row
-          await live.close();
-          return;
-        }
+      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);
-        }
+      /** An opening that never landed leaves nothing to wait for. */
+      const unless = (delivered: boolean) => {
+        if (!delivered) doneReading();
+      };
 
-        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;
+      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);
       }
-    },
-    [
-      status,
-      hangUp,
-      showTool,
-      hideTool,
-      showFace,
-      wearFace,
-      stir,
-      outbox,
-      readAloud,
-      doneReading,
-      holdThinking,
-      showFailed,
-      leave,
-    ],
-  );
+
+      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");
+    }
+  }, [
+    status,
+    hangUp,
+    showTool,
+    hideTool,
+    showFace,
+    wearFace,
+    outbox,
+    readAloud,
+    doneReading,
+    holdThinking,
+    showFailed,
+    leave,
+    isRinging,
+  ]);
 
   /**
-   * 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.
+   * 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 (!threads) return;
-    const wants = threads.filter(
+    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) =>
-        !thread.seen &&
-        !thread.ask?.auto &&
-        (asksSomething(thread) ||
-          (callBack === "any" && thread.status !== "running")),
+        wanted.has(thread.id) && toDate(thread.updatedAt).getTime() > after,
     );
+    if (!fresh.length) return;
 
-    if (!woke.current) {
-      woke.current = new Set(wants.map((thread) => thread.id));
-      return;
-    }
-
-    // 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);
-    }
+    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((thread) => !woke.current?.has(thread.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 thread of wants) woke.current.add(thread.id);
-    void call("callBack");
-  }, [threads, 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, []);
@@ -993,13 +1008,23 @@ export function useThursday() {
     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,
     /** 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. */
@@ -1011,6 +1036,36 @@ export function useThursday() {
 
 const EMPTY_BANDS = new Array<number>(SPECTRUM_BANDS).fill(0);
 
+/** 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
  * AudioContext. Resume on the next pointer or key event and say so on screen.
@@ -1052,6 +1107,15 @@ function statusOf(activity: LiveActivity): LiveStatus {
   return "listening";
 }
 
+/**
+ * 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 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 },
@@ -1073,10 +1137,15 @@ function persist(
 }
 
 /**
- * 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.
  */
-const asksSomething = (thread: Thread) => thread.room.questions.length > 0;
+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 = {