thursday-agent 0.8.0 → 0.9.0

package/features/thursday/components/thursday.tsx

@@ -18,6 +18,7 @@ import {
   useMemo,
   useRef,
   useState,
+  useSyncExternalStore,
 } from "react";
 import { queryKey } from "@/app/api/query-key";
 import { Button } from "@/components/ui/button";
@@ -74,8 +75,14 @@ import { useHotkeyLabel } from "@/hooks/use-hotkey";
 import { RING_CYCLE_MS } from "@/lib/live/ring";
 import { useServerRoute } from "@/lib/protocol/use-server-route";
 import { cn, plainText } from "@/lib/utils";
+import { ConnectWave } from "./connect-wave";
 import { Face } from "./face";
-import { SideCaptions, turnsOf, useTurnFocus } from "./side-captions";
+import {
+  SideCaptions,
+  type Turn,
+  turnsOf,
+  useTurnFocus,
+} from "./side-captions";
 import { TabState } from "./tab-state";
 import { WriteLine, type WrittenCall } from "./write-line";
 
@@ -163,8 +170,10 @@ function CallScreen({
   const hers =
     messages.findLast((turn) => turn.role === "assistant")?.text ?? "";
   // An open thread lies over the right of the call and moves none of it: her face and the
-  // captions are where they were when it closes
-  const sided = captionView === "sides" && status !== "idle";
+  // captions are where they were when it closes. A window too narrow for three columns
+  // draws her last line instead, whatever the setting.
+  const wide = useWide(SIDES_MIN_WIDTH);
+  const sided = captionView === "sides" && status !== "idle" && wide;
   const talk = useMemo(() => turnsOf(messages), [messages]);
   const turns = useTurnFocus(talk, sided);
   const lastRole = talk.at(-1)?.role;
@@ -178,6 +187,10 @@ function CallScreen({
     if (lastRole !== "user") setMaking(false);
     else if (work.on) setMaking(true);
   }, [lastRole, work.on]);
+  // The work behind each of her turns stays with it for the call: what ran while she was on
+  // it, or before she answered, is kept under her words and shows again when she is gone
+  // back to. A later stretch of work on the same turn adds to it
+  const kept = useKeptWork(talk, work.lines);
   // the last turn is still being said: her voice is on, or yours came after hers and she has not answered
   const saying =
     (lastRole === "assistant" && status === "speaking") ||
@@ -196,7 +209,11 @@ function CallScreen({
       {/* Top padding in vh, like the face itself, so the face+text column sits below center */}
       <div className="flex min-h-0 flex-1 flex-col items-center justify-center gap-5 pt-[7vh]">
         {/* The face is the control. It reacts to the agent's own voice. */}
-        <div className="relative w-[min(28rem,72vw,52vh)]">
+        {/* The layout box is the part of her face she fills while talking; the canvas draws
+            `--face-bleed` past it on every side for the room her words, the tail she works
+            with and the gathering need, so what sits under her is not pushed away by empty
+            field. What stands beside her stands past the canvas (SideCaptions). */}
+        <div className="relative w-[min(20rem,52vw,37.5vh)] [--face-bleed:19.5%]">
           <button
             type="button"
             disabled={busy}
@@ -232,10 +249,11 @@ function CallScreen({
                 failed={failed}
                 word={ringWord ?? faceWord}
                 getSpectrum={getSpectrum}
-                className="w-full"
+                className="-m-(--face-bleed) w-[calc(100%+2*var(--face-bleed))] max-w-none"
               />
             </span>
           </button>
+          <ConnectWave status={status} charset={face.charset} />
 
           {sided && (
             <SideCaptions
@@ -244,17 +262,18 @@ function CallScreen({
               live={saying}
               onPick={turns.pick}
               under={
-                work.held ? (
-                  <WorkStack
-                    lines={work.lines}
-                    shown={work.on}
-                    thinkingSince={thinkingSince}
-                    thinkingTitle={thinkingTitle}
-                  />
+                work.held && work.lines.length > 0 ? (
+                  <WorkStack lines={work.lines} shown={work.on} />
+                ) : null
+              }
+              // with the work gone and her answer not yet begun, her last words come back level;
+              // thinking alone takes nothing from them, since it stands under her face
+              ahead={making && work.held && work.lines.length > 0}
+              workOf={(turn) =>
+                kept[turn]?.length ? (
+                  <WorkStack lines={kept[turn]} shown />
                 ) : null
               }
-              // with the work gone and her answer not yet begun, her last words come back level
-              ahead={making && work.held}
             />
           )}
         </div>
@@ -267,6 +286,7 @@ function CallScreen({
           {ringing && (
             <Incoming
               ringing={ringing}
+              wakePhrase={wakePhrase}
               onAnswer={onTap}
               onDecline={() => onDecline?.()}
             />
@@ -278,9 +298,11 @@ function CallScreen({
               (tool-line). The fast channel; the face does not follow it
               (use-thursday). */}
             <ActivityRow
-              // beside her face the work is on her side (WorkStack); this slot keeps the meter
+              // beside her face the lines are on her side (WorkStack); what she is thinking
+              // about and the meter stay here in either view
               tool={sided ? null : drawn}
-              thinkingSince={sided ? null : thinkingSince}
+              toolUp={drawn !== null}
+              thinkingSince={thinkingSince}
               thinkingTitle={thinkingTitle}
               // nobody is listened to on a call in writing: there is no microphone
               listening={
@@ -369,6 +391,25 @@ function CornerDot({ alert }: { alert: SectionAlert }) {
   );
 }
 
+/**
+ * Below this window width the captions down the sides would be narrower than about 15rem
+ * (24vw) and her lines a few words each, so the call draws her last line under her face.
+ */
+const SIDES_MIN_WIDTH = 1000;
+
+/** Whether the window is at least `px` wide, kept current; a server render counts as wide. */
+function useWide(px: number) {
+  return useSyncExternalStore(
+    (listener) => {
+      const query = window.matchMedia(`(min-width: ${px}px)`);
+      query.addEventListener("change", listener);
+      return () => query.removeEventListener("change", listener);
+    },
+    () => window.matchMedia(`(min-width: ${px}px)`).matches,
+    () => true,
+  );
+}
+
 function SettingsCorner() {
   const alerts = useSectionAlerts();
   // The gear opens everything the three buttons do not, so it carries their reports
@@ -719,7 +760,7 @@ function Activity({ tool }: { tool: ActivityLine }) {
       ) : tool.done ? (
         <span className={cn(look, "text-muted-foreground")}>{text}</span>
       ) : (
-        <ShinyText text={text} motion="pulse" className={look} />
+        <ShinyText text={text} className={look} />
       )}
     </span>
   );
@@ -875,13 +916,16 @@ function useHeldThought(
 
 function ActivityRow({
   tool,
+  toolUp,
   thinkingSince,
   thinkingTitle,
   listening,
   getMicSpectrum,
 }: {
-  /** The line to draw now (useDwell). */
+  /** The line to draw here now (useDwell); none while the lines stand beside her face. */
   tool: ActivityLine | null;
+  /** A line is up, here or on her side: it is the same stretch of work, said more exactly. */
+  toolUp: boolean;
   thinkingSince: number | null;
   thinkingTitle: string | null;
   listening: boolean;
@@ -905,7 +949,7 @@ function ActivityRow({
       {thought && (
         <Fade
           at="col-start-1 row-start-1"
-          shown={thinkingSince !== null && !tool}
+          shown={thinkingSince !== null && !toolUp}
         >
           <Thinking title={title} />
         </Fade>
@@ -967,27 +1011,51 @@ function useWork(drawn: ActivityLine | null, thinking: boolean) {
   return { lines, on, held };
 }
 
+/**
+ * The lines of work behind each of her turns, by turn: whatever ran while her latest turn
+ * was hers — before she answered, while she spoke — is that turn's. A turn is theirs until
+ * she speaks, so work before her answer waits for it. Lines are merged by the call they
+ * came from, so a second stretch on one turn adds to the first. A new call starts empty.
+ */
+function useKeptWork(talk: Turn[], lines: ActivityLine[]) {
+  const [kept, setKept] = useState<Record<string, ActivityLine[]>>({});
+  const last = talk.at(-1);
+  const owner = last?.role === "assistant" ? last.id : null;
+  useEffect(() => {
+    if (!owner || !lines.length) return;
+    setKept((was) => {
+      const now = new Set(lines.map(lineKey));
+      const merged = [
+        ...(was[owner] ?? []).filter((line) => !now.has(lineKey(line))),
+        ...lines,
+      ];
+      const same =
+        was[owner]?.length === merged.length &&
+        merged.every((line, k) => line === was[owner]?.[k]);
+      return same ? was : { ...was, [owner]: merged };
+    });
+  }, [owner, lines]);
+  useEffect(() => {
+    if (!talk.length) setKept({});
+  }, [talk.length]);
+  return kept;
+}
+
 /**
  * What she is doing, on her side of the captions and under her words: the last few lines
- * of work, older ones fainter, and what the backend is thinking about under them. No rule
- * and no plate — the glyphs at the head of the lines are what set them apart from her words.
+ * of work, older ones fainter. No rule and no plate — the glyphs at the head of the lines
+ * are what set them apart from her words. What she is thinking about stays under her face.
  */
 function WorkStack({
   lines,
   shown,
-  thinkingSince,
-  thinkingTitle,
 }: {
   lines: ActivityLine[];
   /** The stretch of work is still open; false is the fade on its way out. */
   shown: boolean;
-  thinkingSince: number | null;
-  thinkingTitle: string | null;
 }) {
-  const { thought, title } = useHeldThought(thinkingSince, thinkingTitle);
   const leaving = Math.max(0, lines.length - WORK_LINES);
   const rows = lines.length - leaving;
-  const newest = lines.at(-1);
   return (
     <div
       aria-hidden={!shown}
@@ -995,7 +1063,7 @@ function WorkStack({
         "pointer-events-auto relative w-[min(100%,16.5rem)] transition-opacity duration-300 ease-out",
         !shown && "pointer-events-none opacity-0",
       )}
-      style={{ height: (rows + 1) * WORK_ROW }}
+      style={{ height: rows * WORK_ROW }}
     >
       {lines.map((line, k) => {
         const row = k - leaving;
@@ -1016,23 +1084,6 @@ function WorkStack({
           </div>
         );
       })}
-      {thought && (
-        <div
-          style={{
-            transform: `translateY(${rows * WORK_ROW}px)`,
-            height: WORK_ROW,
-          }}
-          className="absolute inset-x-0 top-0 flex items-center transition-transform duration-300 ease-out motion-reduce:transition-none"
-        >
-          {/* A tool wins over thinking: it is the same stretch of work, said more exactly */}
-          <Fade
-            at={cn("min-w-0", rows > 0 && "pl-6")}
-            shown={thinkingSince !== null && (!newest || newest.done)}
-          >
-            <Thinking title={title} />
-          </Fade>
-        </div>
-      )}
     </div>
   );
 }
@@ -1072,10 +1123,13 @@ const KEY_CAP =
  */
 function Incoming({
   ringing,
+  wakePhrase,
   onAnswer,
   onDecline,
 }: {
   ringing: Ringing;
+  /** Saying it answers as the button does (use-thursday `call`); null while it is off. */
+  wakePhrase: string | null;
   onAnswer: () => void;
   onDecline: () => void;
 }) {
@@ -1144,6 +1198,11 @@ function Incoming({
         >
           Call back
         </Button>
+        {wakePhrase && (
+          <span className="mt-3 flex items-center gap-1.5 font-mono text-[11px] text-muted-foreground/70">
+            or say <SaidPhrase phrase={wakePhrase} />
+          </span>
+        )}
       </div>
     );
   }
@@ -1198,18 +1257,35 @@ function Incoming({
           )}
         </span>
       )}
-      <button
-        type="button"
-        onClick={onDecline}
-        className="mt-1 flex items-center gap-2 rounded-md font-mono text-[11px] text-muted-foreground/70 outline-none hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50"
-      >
-        <kbd className={KEY_CAP}>Esc</kbd>
-        not now
-      </button>
+      <span className="mt-1 flex items-center gap-3 font-mono text-[11px] text-muted-foreground/70">
+        {wakePhrase && (
+          <span className="flex items-center gap-1.5">
+            say <SaidPhrase phrase={wakePhrase} /> to answer
+          </span>
+        )}
+        <button
+          type="button"
+          onClick={onDecline}
+          className="flex items-center gap-2 rounded-md outline-none hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50"
+        >
+          <kbd className={KEY_CAP}>Esc</kbd>
+          not now
+        </button>
+      </span>
     </div>
   );
 }
 
+/** The wake phrase as the screen shows it wherever saying it does something. */
+function SaidPhrase({ phrase }: { phrase: string }) {
+  return (
+    <span className="flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-foreground/80">
+      <Mic className="size-3" />
+      {phrase}
+    </span>
+  );
+}
+
 /** What a waiting thread is doing, in one word. */
 const RUNG_KIND: Record<Rung["kind"], string> = {
   question: "asks",
@@ -1284,7 +1360,6 @@ function Hint({
     body = (
       <ShinyText
         text={status === "connecting" ? "Connecting…" : "Ending…"}
-        motion="pulse"
         className="text-muted-foreground/70"
       />
     );
@@ -1324,10 +1399,7 @@ function Hint({
     body = (
       <>
         <span>Tap Thursday, or say</span>
-        <span className="flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-foreground/80">
-          <Mic className="size-3" />
-          {wakePhrase}
-        </span>
+        <SaidPhrase phrase={wakePhrase} />
       </>
     );
   } else if (hotkeyLabel) {

package/features/thursday/components/voice-picker.tsx

@@ -226,7 +226,7 @@ export function VoicePicker({
                 </span>
                 <Check
                   className={cn(
-                    "size-3.5 shrink-0 text-brand",
+                    "size-3.5 shrink-0",
                     name === voice ? "opacity-100" : "opacity-0",
                   )}
                 />

package/features/thursday/components/write-line.tsx

@@ -316,7 +316,7 @@ export function WriteLine({
           aria-hidden
           className="pointer-events-none fixed inset-0 z-20 bg-background/60"
         >
-          <div className="absolute inset-3 rounded-3xl border-[1.5px] border-dashed border-brand/55" />
+          <div className="absolute inset-3 rounded-3xl border-[1.5px] border-dashed border-foreground/30" />
         </div>
       )}
       <div
@@ -337,7 +337,7 @@ export function WriteLine({
                 className="px-0.5 pt-0.5"
               >
                 {dragging && (
-                  <span className="flex h-13 items-center gap-2 rounded-[14px] border-[1.5px] border-dashed border-brand px-4 text-[13px] text-brand">
+                  <span className="flex h-13 items-center gap-2 rounded-[14px] border-[1.5px] border-dashed border-foreground/60 px-4 text-[13px]">
                     <ArrowDownToLine className="size-4" />
                     Let go — it waits here
                   </span>

package/features/thursday/open-work.ts

@@ -32,6 +32,14 @@ export type OpenWork = {
   show: ActivityLine;
 };
 
+/** What a bot's message to the call does, as its line on the call screen says it after the bot's name. */
+const RELAY_SAYS: Record<Thread["room"]["relays"][number]["kind"], string> = {
+  message: "says",
+  question: "asks",
+  report: "reports",
+  interrupted: "was cut off",
+};
+
 const OPEN_RANK = {
   question: 0,
   stopped: 1,
@@ -95,7 +103,7 @@ export function openWork(threads: Thread[]): OpenWork[] {
         relayIds: relays
           .filter((relay) => relay.messageId === question.id)
           .map((relay) => relay.id),
-        show: show(question.bot, `${question.bot}: question`),
+        show: show(question.bot, `${question.bot} asks`),
       });
     }
 
@@ -127,7 +135,7 @@ export function openWork(threads: Thread[]): OpenWork[] {
           thread.bot,
           kind === "stopped"
             ? `${thread.bot} stopped`
-            : `Answer from ${thread.bot}`,
+            : `${thread.bot} finished`,
         ),
       });
       continue;
@@ -140,7 +148,7 @@ export function openWork(threads: Thread[]): OpenWork[] {
         kind: "progress",
         line: `${bracket(relay.bot, relay.kind)}\n${spoken(relay.text)}`,
         relayIds: [relay.id],
-        show: show(relay.bot, `${relay.bot}: ${relay.kind}`),
+        show: show(relay.bot, `${relay.bot} ${RELAY_SAYS[relay.kind]}`),
       });
     }
   }

package/features/thursday/tool-line.ts

@@ -1,4 +1,5 @@
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import type { Thread } from "@/features/bot/bot.schema";
 
 // Human-readable activity lines for tool calls on the call screen. The model
 // never reads these. Unknown names resolve to null and the screen shows the name.
@@ -6,13 +7,36 @@ const LINES: Record<string, string> = {
   [TOOL_NAMES.memory_recall]: "Checking your notes",
   [TOOL_NAMES.memory_remember]: "Noting that down",
   [TOOL_NAMES.memory_forget]: "Forgetting that",
+  [TOOL_NAMES.memory_conversation]: "Reading back an earlier call",
   [TOOL_NAMES.bash]: "Doing it on this computer",
   [TOOL_NAMES.web_search]: "Searching the web",
   [TOOL_NAMES.load_skill]: "Reading how to do this",
   [TOOL_NAMES.look_at]: "Looking at the picture",
   [TOOL_NAMES.end_call]: "Ending the call",
+  [TOOL_NAMES.routine]: "Checking your routines",
 };
 
+/** When a routine being made starts, as the call's arguments say it: "once at 19:10", "every 6 hours". */
+function routineWhen(args: Record<string, unknown>): string | null {
+  if (typeof args.at === "string" && args.at.length >= 16) {
+    const [day, time] = args.at.split(" ");
+    const [year, month, date] = day.split("-").map(Number);
+    const on = new Date(year, month - 1, date);
+    if (on.toDateString() === new Date().toDateString())
+      return `once at ${time}`;
+    const named = on.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+    });
+    return `once, ${named} ${time}`;
+  }
+  if (typeof args.time === "string" && args.time)
+    return `daily at ${args.time}`;
+  if (typeof args.everyHours === "number")
+    return `every ${args.everyHours} hours`;
+  return null;
+}
+
 /**
  * How much of a fact the line carries. What is being written is the one thing
  * on this screen the user cannot check afterwards without opening the note, so
@@ -48,7 +72,11 @@ function firstFact(
 }
 
 /** Lines that need the arguments; arguments may still be streaming in. */
-function fromArgs(name: string, args: Record<string, unknown>): string | null {
+function fromArgs(
+  name: string,
+  args: Record<string, unknown>,
+  bot: string | null,
+): string | null {
   if (name === TOOL_NAMES.memory_remember) {
     const path = typeof args.path === "string" ? args.path.trim() : "";
     const fact = firstFact(args);
@@ -65,10 +93,26 @@ function fromArgs(name: string, args: Record<string, unknown>): string | null {
     const query = typeof args.query === "string" ? args.query.trim() : "";
     return query ? `Searching · ${query}` : null;
   }
+  if (name === TOOL_NAMES.routine) {
+    if (args.action === "create") {
+      const bot = typeof args.bot === "string" ? args.bot.trim() : "";
+      const when = routineWhen(args);
+      const what = [bot, when].filter(Boolean).join(", ");
+      return what ? `Setting a routine · ${what}` : "Setting a routine";
+    }
+    if (args.action === "change") return "Changing a routine";
+    if (args.action === "delete") return "Deleting a routine";
+    return null;
+  }
   const label = typeof args.thread === "string" ? args.thread.trim() : "";
-  if (name === TOOL_NAMES.thread_tell || name === TOOL_NAMES.thread_answer)
-    return "Passing that on";
-  if (name === TOOL_NAMES.thread_cancel) return "Stopping that";
+  if (name === TOOL_NAMES.thread_tell)
+    return bot ? `Telling ${bot}` : "Passing that on";
+  if (name === TOOL_NAMES.thread_answer)
+    return bot ? `Answering ${bot}` : "Answering that";
+  if (name === TOOL_NAMES.thread_cancel)
+    return label ? `Stopping ${label}` : "Stopping that";
+  if (name === TOOL_NAMES.thread_seen)
+    return label ? `Marking ${label} as read` : "Marking that as read";
   if (name === TOOL_NAMES.thread_show)
     return label ? `Opening ${label}` : "Opening that";
   if (name === TOOL_NAMES.thread_status)
@@ -99,22 +143,60 @@ function parseArgs(args?: string): Record<string, unknown> | null {
   return null;
 }
 
-export function toolLine(name: string, args?: string): string | null {
+/** The line for a tool call; `bot` is who it reaches (`toolBot`), for the lines that name them. */
+export function toolLine(
+  name: string,
+  args?: string,
+  bot: string | null = null,
+): string | null {
   if (name === TOOL_NAMES.tool_search || name === TOOL_NAMES.tool_call) {
     return "Reaching a connected service";
   }
   const parsed = parseArgs(args);
-  return (parsed && fromArgs(name, parsed)) ?? LINES[name] ?? fromServer(name);
+  return (
+    (parsed && fromArgs(name, parsed, bot)) ?? LINES[name] ?? fromServer(name)
+  );
 }
 
+/** The call's tools that act on one thread the model names by its label or id. */
+const ON_A_THREAD = new Set<string>([
+  TOOL_NAMES.thread_tell,
+  TOOL_NAMES.thread_answer,
+  TOOL_NAMES.thread_status,
+  TOOL_NAMES.thread_show,
+  TOOL_NAMES.thread_cancel,
+  TOOL_NAMES.thread_seen,
+]);
+
 /**
- * The bot a call hands work to, when it names one. The row draws that bot's own
- * face instead of a glyph: who it went to is a face everywhere else in the app.
+ * The bot a call's tool reaches, so its row wears that bot's face rather than a glyph —
+ * who work went to is a face everywhere else in the app. The one work is handed to, else
+ * the bot of the thread the tool names, found as the server finds a thread (thread.query
+ * resolveThread): its id, else its label. An answer goes to the bot that asked; "all", and
+ * a thread the page does not hold, reach nobody in particular.
  */
-export function toolBot(name: string, args?: string): string | null {
-  if (name !== TOOL_NAMES.thread_start) return null;
-  const bot = parseArgs(args)?.bot;
-  return typeof bot === "string" && bot.trim() ? bot.trim() : null;
+export function toolBot(
+  name: string,
+  args?: string,
+  threads?: Thread[],
+): string | null {
+  const parsed = parseArgs(args);
+  if (!parsed) return null;
+  if (name === TOOL_NAMES.thread_start)
+    return typeof parsed.bot === "string" && parsed.bot.trim()
+      ? parsed.bot.trim()
+      : null;
+  if (!ON_A_THREAD.has(name) || !threads) return null;
+  const ref = typeof parsed.thread === "string" ? parsed.thread.trim() : "";
+  if (!ref || ref.toLowerCase() === "all") return null;
+  const lower = ref.toLowerCase();
+  const thread =
+    threads.find((one) => one.id === ref) ??
+    threads.find((one) => one.label.toLowerCase() === lower);
+  if (!thread) return null;
+  return name === TOOL_NAMES.thread_answer
+    ? (thread.room.questions[0]?.bot ?? thread.bot)
+    : thread.bot;
 }
 
 /**

package/features/thursday/use-text-call.ts

@@ -285,11 +285,12 @@ export function useTextCall(): TextCall {
         ? searchSourcesOf(JSON.stringify(lastTool.output ?? null))
         : [];
     if (last?.type === "text" && !sources.length) return null;
+    const bot = toolBot(name, args, inbox.current);
     return {
       id: lastTool.toolCallId,
       name,
-      line: toolLine(name, args),
-      bot: toolBot(name, args),
+      line: toolLine(name, args, bot),
+      bot,
       done,
       ...(sources.length ? { sources } : {}),
     };

package/features/thursday/use-thursday.ts

@@ -16,6 +16,7 @@ import { acceptThreadRelaysAction } from "@/features/bot/bot.action";
 import type { Bot, Thread } from "@/features/bot/bot.schema";
 import { botThreads, screenActs } from "@/features/bot/thread.store";
 import { runRemoteTool } from "@/features/thursday/tool-call";
+import { askToNotify } from "@/features/workspace/components/artifact-view";
 import { isCombo, useHotkey } from "@/hooks/use-hotkey";
 import { useWakeWord } from "@/hooks/use-wake-word";
 import type { LiveClose } from "@/lib/live/live.schema";
@@ -256,11 +257,12 @@ export function useThursday(
   const showTool = useCallback((call: LiveToolCall) => {
     if (linger.current) clearTimeout(linger.current);
     relayOpen.current = false;
+    const bot = toolBot(call.name, call.arguments, latest.current);
     setTool({
       id: call.id,
       name: call.name,
-      line: toolLine(call.name, call.arguments),
-      bot: toolBot(call.name, call.arguments),
+      line: toolLine(call.name, call.arguments, bot),
+      bot,
       done: false,
     });
   }, []);
@@ -708,6 +710,7 @@ export function useThursday(
     // with a line open this press hangs up; `calling` covers the gap before re-render
     if (calling.current || status !== "idle") return hangUp();
     answered();
+    askToNotify();
 
     setStatus("connecting");
     setEnded(null);