thursday-agent 0.9.0 → 0.11.0

package/features/thursday/tool-line.ts

@@ -172,13 +172,15 @@ const ON_A_THREAD = new Set<string>([
  * 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.
+ * resolveThread): its id, else its label. An answer goes to the bot that asked; "all"
+ * reaches nobody in particular. A thread the page does not hold — stopped and read, or
+ * finished longer ago than the inbox keeps — is named by the tool's answer once it is back.
  */
 export function toolBot(
   name: string,
   args?: string,
   threads?: Thread[],
+  output?: string,
 ): string | null {
   const parsed = parseArgs(args);
   if (!parsed) return null;
@@ -186,19 +188,28 @@ export function toolBot(
     return typeof parsed.bot === "string" && parsed.bot.trim()
       ? parsed.bot.trim()
       : null;
-  if (!ON_A_THREAD.has(name) || !threads) return null;
+  if (!ON_A_THREAD.has(name)) 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;
+    threads?.find((one) => one.id === ref) ??
+    threads?.find((one) => one.label.toLowerCase() === lower);
+  if (!thread) return answeredBy(output);
   return name === TOOL_NAMES.thread_answer
     ? (thread.room.questions[0]?.bot ?? thread.bot)
     : thread.bot;
 }
 
+/** Whom a thread tool's answer says it reached (load-tools): `bot`, or the bot that took it as its answer. */
+function answeredBy(output?: string): string | null {
+  const said = parseArgs(output);
+  if (!said) return null;
+  if (typeof said.bot === "string" && said.bot.trim()) return said.bot.trim();
+  const answered = said.answered as { bot?: unknown } | null | undefined;
+  return typeof answered?.bot === "string" ? answered.bot : null;
+}
+
 /**
  * The label a thread was started under, or null for any other turn. It is
  * how a job is found again from the line that opened it — in her prompt and in

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

@@ -6,7 +6,6 @@ import type { Thread } from "@/features/bot/bot.schema";
 import { ringingThreads } from "@/features/bot/thread.store";
 import { toDate } from "@/lib/date-like";
 import { createRing } from "@/lib/live/ring";
-import { createProbe } from "@/lib/probe";
 import type { CallBack } from "./thursday.schema";
 import { useThursdayStore } from "./thursday.store";
 
@@ -51,7 +50,6 @@ export function useCallRing({
   /** A call in writing holds the screen (use-text-call): nothing rings meanwhile. */
   writing: boolean;
 }) {
-  const probe = useRef(createProbe("page")).current;
   /**
    * The call-back rings only for threads that changed after this: the last call's
    * end, the last ring, or the page opening.
@@ -84,7 +82,6 @@ export function useCallRing({
     );
     if (!fresh.length) return;
 
-    probe("ring", { threads: fresh.map((thread) => thread.id) });
     ringAfter.current = Date.now();
     // Work that is new to it rings again, even if it had rung out
     setRangOutAt(null);
@@ -92,7 +89,7 @@ export function useCallRing({
       ...ids,
       ...fresh.map((thread) => thread.id).filter((id) => !ids.includes(id)),
     ]);
-  }, [threads, callBack, resting, writing, probe]);
+  }, [threads, callBack, resting, writing]);
 
   // Writing to her answers a ring as calling her does, and what came up while they wrote
   // was that call's to tell: nothing from before its end rings afterwards
@@ -110,7 +107,6 @@ export function useCallRing({
    * A thread added to a ring already going does not restart the clock.
    */
   const decline = useCallback(() => {
-    probe("ring.declined");
     setRingingFor([]);
     setRangOutAt(null);
   }, []);

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

@@ -267,34 +267,50 @@ export function useTextCall(): TextCall {
   // pages a search read stay through her answer, until the next words are sent, as on a
   // spoken call
   const lastTool = [...parts].reverse().find(isToolUIPart);
-  const used = useMemo((): ActivityLine | null => {
-    if (!lastTool) return null;
-    const name = getToolName(lastTool);
-    // A provider's own search names what it looked for in its answer, not in what it was asked
-    const asked = (lastTool.output as { action?: { query?: unknown } } | null)
-      ?.action?.query;
-    const args = JSON.stringify({
-      ...(typeof asked === "string" ? { query: asked } : {}),
-      ...(lastTool.input ?? {}),
-    });
-    const done =
-      lastTool.state === "output-available" ||
-      lastTool.state === "output-error";
-    const sources =
+  // The part is copied with every piece of the stream, and its arguments arrive a few
+  // characters a piece: the line is a new object only when what it draws changes, or
+  // every piece redraws the call screen several times over
+  const id = lastTool?.toolCallId ?? null;
+  const name = lastTool ? getToolName(lastTool) : null;
+  const done =
+    lastTool?.state === "output-available" ||
+    lastTool?.state === "output-error";
+  const output = lastTool?.output;
+  const sources = useMemo(
+    () =>
       done && name === TOOL_NAMES.web_search
-        ? searchSourcesOf(JSON.stringify(lastTool.output ?? null))
-        : [];
-    if (last?.type === "text" && !sources.length) return null;
-    const bot = toolBot(name, args, inbox.current);
+        ? searchSourcesOf(JSON.stringify(output ?? null))
+        : [],
+    [done, name, output],
+  );
+  // A provider's own search names what it looked for in its answer, not in what it was asked
+  const asked = (output as { action?: { query?: unknown } } | null | undefined)
+    ?.action?.query;
+  const args = JSON.stringify({
+    ...(typeof asked === "string" ? { query: asked } : {}),
+    ...(lastTool?.input ?? {}),
+  });
+  const bot = name
+    ? toolBot(
+        name,
+        args,
+        inbox.current,
+        output === undefined ? undefined : JSON.stringify(output),
+      )
+    : null;
+  const drawn = name ? toolLine(name, args, bot) : null;
+  const answered = last?.type === "text";
+  const used = useMemo((): ActivityLine | null => {
+    if (!id || !name || (answered && !sources.length)) return null;
     return {
-      id: lastTool.toolCallId,
+      id,
       name,
-      line: toolLine(name, args, bot),
+      line: drawn,
       bot,
       done,
       ...(sources.length ? { sources } : {}),
     };
-  }, [lastTool, last?.type]);
+  }, [id, name, drawn, bot, done, sources, answered]);
   const [lingered, setLingered] = useState<string | null>(null);
   const usedId = used?.done && !used.sources ? used.id : null;
   useEffect(() => {

package/features/thursday/use-thursday.ts

@@ -4,13 +4,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useAppEvent } from "@/app/api/events/app-event.client";
 import { queryKey } from "@/app/api/query-key";
 import { toast } from "@/components/ui/toast";
-import {
-  CALL_END,
-  CALL_ENDED_MS,
-  CALL_IDLE,
-  CALL_NUDGE,
-  CALL_RELAY,
-} from "@/config";
+import { CALL_END, CALL_ENDED_MS, 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, Thread } from "@/features/bot/bot.schema";
@@ -32,7 +26,6 @@ import {
   createAudioTap,
   SPECTRUM_BANDS,
 } from "@/lib/live/live.tap";
-import { createProbe } from "@/lib/probe";
 import { type Result, unwrapResult } from "@/lib/protocol/result";
 import {
   revalidate,
@@ -216,8 +209,6 @@ export function useThursday(
   const onLine = useRef<string[]>([]);
   /** That update's relay rows, accepted once she has voiced it. */
   const onLineRows = useRef<number[]>([]);
-  /** The experiment's timer (config CALL_NUDGE): a backend turn the page starts itself. */
-  const nudge = useRef<ReturnType<typeof setTimeout> | null>(null);
   /** 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. */
@@ -267,12 +258,22 @@ export function useThursday(
     });
   }, []);
 
+  /** The tool's answer is back: a thread the page does not hold is named by it (toolBot). */
+  const nameTool = useCallback((call: LiveToolCall, output: string) => {
+    const bot = toolBot(call.name, call.arguments, latest.current, output);
+    if (!bot) return;
+    setTool((open) =>
+      open?.id === call.id && open.bot !== bot
+        ? { ...open, bot, line: toolLine(call.name, call.arguments, bot) }
+        : open,
+    );
+  }, []);
+
   /**
    * 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 probe = useRef(createProbe("page")).current;
   const showRelay = useCallback((run: ActivityLine) => {
     if (linger.current) clearTimeout(linger.current);
     relayOpen.current = true;
@@ -295,7 +296,6 @@ export function useThursday(
   /** 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);
-    probe("read.done", { spoke: reading.current.spoke, keys: onLine.current });
     // Her voice started and stopped on it: carried, and only now are its rows accepted.
     // Live's acknowledgement says the text arrived, not that anyone heard it
     if (reading.current.spoke) {
@@ -419,13 +419,6 @@ export function useThursday(
     }
     // Finished work is good news before she says it (an item's key opens with what it is)
     if (first.key.startsWith("done:")) setFaceWord(finished());
-    probe("relay.out", {
-      kind: first.kind,
-      keys: due.map((item) => item.key),
-      waiting: open.length - due.length,
-      quietMs: Date.now() - heard.current,
-      rung,
-    });
     readAloud();
     onLine.current = due.map((item) => item.key);
     onLineRows.current = due.flatMap((item) => item.relayIds);
@@ -439,7 +432,6 @@ export function useThursday(
           : `[${lines.length} updates.]\n\n${lines.join("\n\n")}`,
       )
       .then((delivered) => {
-        probe("relay.acked", { delivered });
         // Refused: nothing to wait for her voice on
         if (!delivered) {
           onLineRows.current = [];
@@ -572,12 +564,6 @@ export function useThursday(
     async (why: CallEnd | null = null) => {
       if (ending.current) return;
       ending.current = true;
-      probe("hangup", {
-        why,
-        call: callId.current,
-        unvoiced: [...unvoiced.current],
-        reading: reading.current.on,
-      });
       if (leaving.current) clearInterval(leaving.current);
       leaving.current = null;
       attempt.current += 1;
@@ -665,7 +651,6 @@ export function useThursday(
   const leave = useCallback(() => {
     if (leaving.current) return;
     const asked = Date.now();
-    probe("end_call", { sinceVoiceMs: asked - voiced.current });
     leaving.current = setInterval(() => {
       const now = Date.now();
       // A goodbye heard just before the backend ended the call counts as said
@@ -703,7 +688,6 @@ export function useThursday(
   const call = useCallback(async () => {
     // Every way in answers a ringing call-back: the face, the wake word, the hotkey
     const calledBack = ring.isRinging;
-    probe("call", { calledBack, ringingFor: ring.ringingFor });
     // 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;
@@ -831,8 +815,6 @@ export function useThursday(
               if (word) setFaceWord({ text: word, at: Date.now() });
               return reply;
             }
-            const began = Date.now();
-            probe("tool.run", { name: call.name, id: call.id });
             showTool(call);
             // Exa's search, while its key is set (load-tools): its pages come back with
             // the answer and stay on the line the way the hosted search's do
@@ -846,6 +828,7 @@ export function useThursday(
                 settings.webSearch,
                 stop.signal,
               );
+              nameTool(call, output);
               if (searching)
                 kept = keepSearch({
                   id: call.id,
@@ -857,7 +840,6 @@ export function useThursday(
                 });
               return output;
             } finally {
-              probe("tool.done", { id: call.id, ms: Date.now() - began });
               if (!kept) hideTool(call.id);
             }
           },
@@ -946,19 +928,6 @@ export function useThursday(
                   .slice(-KEEP_MESSAGES),
               );
             }
-            // The experiment (config CALL_NUDGE): their words have settled, and if the voice
-            // hands nothing over in a moment the page starts the backend turn itself
-            if (CALL_NUDGE.on && turn.done && turn.role === "user" && words) {
-              if (nudge.current) clearTimeout(nudge.current);
-              const spoke = stirred.current;
-              nudge.current = setTimeout(() => {
-                nudge.current = null;
-                // they went on talking, or the backend has the turn already
-                if (stirred.current !== spoke || thinking.current !== null)
-                  return;
-                probe("nudge", { sent: session.current?.nudge() ?? false });
-              }, CALL_NUDGE.waitMs);
-            }
             if (turn.done) {
               persist(saving, () =>
                 saveTurnsAction(line.callId, [
@@ -1076,6 +1045,7 @@ export function useThursday(
     status,
     hangUp,
     showTool,
+    nameTool,
     hideTool,
     showFace,
     wearFace,

package/features/workspace/workspace.ts

@@ -207,11 +207,13 @@ export const jobShellEnv = (
 });
 
 /**
- * A bot's artifacts folder in its shell, for a script that delivers a file
- * rather than a model typing the path (skills/interactive-page scripts/page.mjs).
+ * What a bot's scripts find in its shell rather than a model typing the path.
  */
 export const botShellEnv = (bot: string): Record<string, string> => ({
+  // Where a script delivers a file (skills/interactive-page scripts/page.mjs)
   THURSDAY_ARTIFACTS: botArtifacts(bot),
+  // The shipped skills: a kit script in a bot's folder imports the shared ones from here
+  THURSDAY_SKILLS: join(APP_DIR, PATHS.skills.default),
 });
 
 /** A participant's browser belongs to the job and its canonical bot name, across every caller. */

package/guide/bots.md

@@ -10,8 +10,11 @@ switched on; any of them can be switched off there, and added later from the sam
 
 Every bot has the same kit: a shell on this computer, a real browser of its own or the one
 the user is already signed into, their files, the web, whatever skills and connected services
-are installed, and the other bots. A ready-made bot may also arrive with written methods of
-its own for its subject, which no other bot sees.
+are installed, and the other bots. A ready-made bot may also arrive with written methods and
+scripts of its own for its subject, which no other bot sees: Insta studies accounts that do well
+in a niche, builds posts the same way and reads messages without opening them (an opened thread
+shows as seen); Analyst fetches published series and draws them; Marketer keeps one brief per
+product in its memory and works from it.
 
 ## A job is a thread
 
@@ -75,6 +78,13 @@ of itself. Asking her on a call to show a result opens that file on the screen.
 stay under **Settings › Files**, one shelf per bot. Its second tab, **All files**, is the
 whole folder, for looking around rather than for the results.
 
+Asked to explain something simply, **Tutor** makes a picture book: a picture and a line
+or two a page, turned by swiping, the arrow keys, or tapping the right or left of the page. The
+same book can be a PDF, or a video that reads itself aloud (landscape, or portrait when asked);
+when the request does not say which, it asks first. It remembers what the user already
+knows and how they liked being taught. The video needs a speech model in **Settings › Models**, and a drawn
+picture an image model; without one it asks for it and stops.
+
 A bot keeps its own memory — what a job taught it, how the user asked it to work — in its own
 folder, listed on its page in Settings › Bots.
 
@@ -94,7 +104,7 @@ one switch. **When** has three kinds of time, and at most twelve routines exist:
 - **Every few hours**: 1, 2, 3, 6, 12 or 24 hours after each start; any other number can be
   asked of Thursday.
 
-What is picked is filled black, and the line under the field says it back in words, with when
+What is picked is filled blue, and the line under the field says it back in words, with when
 it first starts.
 
 Each time it is due, a routine opens an ordinary thread, marked with a repeat sign, and that

package/guide/calls.md

@@ -11,7 +11,8 @@ Three ways in, and any of them also answers a call she placed:
 
 She speaks first. From the second call on she is told, as the call opens, when the last one
 was and how it ended, so she can greet as someone who remembers it; a call she places herself
-opens on why she called instead.
+opens on why she called instead. She speaks the language the user speaks and switches when they
+do; the browser's language plays no part, so the very first greeting is in whatever she picks.
 
 The wake phrase and the shortcut are in **Settings › Thursday › Starting a call**, where
 either can be switched on or off, or rewritten. The first-run setup offers the wake phrase
@@ -42,10 +43,11 @@ in **Settings › Thursday**. With nothing to run on it says so and sends nothin
 **Settings › API keys**. **Esc** ends it — saying goodbye does not, since there is no
 line for her to drop — and so does starting a spoken call: tapping her face in the middle of
 one ends the written call and places a spoken one. When a turn breaks — a plan's limit, a
-refused key — her face says ERROR and the provider's own words show in red under the line;
-writing again tries again, and Esc still ends it. When an OpenAI key is set and was not what
-broke, a blue button sends the same words again on that key; it never switches by itself,
-since what a turn costs changes with what it runs on. It is kept with
+refused key — her face says ERROR and the provider's own words show in red under the line,
+over a blue **Send it again** and the way to **API keys**; writing again tries again too, and
+Esc still ends it. When an OpenAI key is set and was not what broke, the button sends the same
+words again on that key instead; it never switches by itself, since what a turn costs changes
+with what it runs on. It is kept with
 the other calls, marked *in writing*, and she reads it back on the next call like any other.
 During a spoken call the line writes to bots only — but a file put down then (dropped on the
 window, pasted, or picked with the paperclip) is one she is told about as it lands: its chip

package/knip.json

@@ -3,6 +3,7 @@
   "entry": ["scripts/intro-voice.mts", ".agents/skills/*/*.cjs"],
   "ignore": [
     "skills/**",
+    "seed-skills/**",
     "components/ui/**",
     ".agents/skills/!(verify|cleanup|checkup)/**"
   ],

package/lib/live/live.session.ts

@@ -1,6 +1,5 @@
 import { LIVE_CALL } from "@/config";
 import { logger } from "@/lib/logger";
-import { briefLiveEvent, createProbe } from "@/lib/probe";
 import { errorToString } from "@/lib/utils";
 import {
   LIVE_HOSTED_TOOLS,
@@ -9,8 +8,6 @@ import {
 } from "./live.schema";
 import { createWebRtcTransport } from "./live.transport";
 
-const probe = createProbe("live");
-
 /** A revisable display group, independent of audio playback and backend responses. */
 export type LiveTurn = {
   id: string;
@@ -313,12 +310,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       return;
     const [next] = appends;
     pendingAppend = crypto.randomUUID();
-    probe("out", {
-      type: `session.${next.kind}.append`,
-      client: pendingAppend,
-      head: next.chunks[0].slice(0, 80),
-      chunksLeft: next.chunks.length,
-    });
     transport.send({
       type: `session.${next.kind}.append`,
       event_id: pendingAppend,
@@ -405,7 +396,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       return;
     response.continued = true;
     await Promise.all(response.calls.values());
-    probe("out", { type: "response.create", closing, closed });
     if (!closing && !closed) {
       continuedAt = performance.now();
       transport.send({
@@ -422,8 +412,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       events.add(event.event_id);
     }
     timeline = Math.max(timeline, event.offset_ms ?? 0, event.end_ms ?? 0);
-    if (!event.type.endsWith(".delta") && !event.event?.type.endsWith(".delta"))
-      probe("in", briefLiveEvent(event));
     switch (event.type) {
       case "session.started":
         started = true;
@@ -576,12 +564,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
             .catch((cause) => `Error: ${errorToString(cause)}`)
             .then((output) => {
               tools.delete(item.call_id);
-              probe("out", {
-                type: "function_call_output",
-                name: item.name,
-                call: item.call_id,
-                size: output.length,
-              });
               if (!closed && !closing)
                 transport.send({
                   type: "response.item.create",
@@ -690,7 +672,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
         cleanup();
       }, LIVE_CALL.closeMs);
       audio.element.muted = true;
-      probe("out", { type: "session.close" });
       transport.send({ type: "session.close", event_id: crypto.randomUUID() });
       return closePromise;
     },
@@ -708,25 +689,5 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
         appendNext();
       });
     },
-    /**
-     * Starts a backend turn the voice did not hand over: the same `response.create` that
-     * continues delegated work, sent with nothing pending. Does nothing while the backend
-     * already holds the turn, or once the call is closing. False when it was not sent.
-     */
-    nudge(): boolean {
-      const busy =
-        [...responses.values()].some((response) => !response.terminal) ||
-        tools.size > 0 ||
-        performance.now() - continuedAt < CONTINUE_GAP_MS;
-      if (closed || closing || busy) return false;
-      probe("out", { type: "response.create", nudge: true });
-      continuedAt = performance.now();
-      transport.send({
-        type: "response.create",
-        event_id: crypto.randomUUID(),
-      });
-      activity();
-      return true;
-    },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thursday-agent",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "A voice agent that runs on your own machine — talk to her, she hands the slow work to bots with a shell, a browser and skills.",
   "license": "MIT",
   "keywords": [

package/scripts/live-session.test.mts

@@ -860,7 +860,7 @@ test("stored settings keep OpenAI choices and the shared instruction, drop a Gro
   assert.deepEqual(migrateLiveSettings(null), LIVE_DEFAULTS);
 });
 
-test("both call prompts open as one Thursday: the voice gets a two-line delegation policy and memory and no earlier calls, the backend carries work on in threads, and every call has an opening", async () => {
+test("both call prompts open as one Thursday: the voice gets the guide's delegation policy and memory and no earlier calls, the backend carries work on in threads, and every call has an opening", async () => {
   let profileFacts = 200;
   let samFacts = 2;
   const botMock = mock.module("../features/bot/bot.query.ts", {
@@ -949,13 +949,12 @@ test("both call prompts open as one Thursday: the voice gets a two-line delegati
     );
     const on = await loadLivePrompt({
       voicePrompt: "Use a calm voice.",
-      locale: "ko-KR",
     });
     assert.match(on.text, /modeled on Friday, the AI in \*Iron Man\*/);
     assert.match(on.text, /Prefer brief replies/);
     assert.match(
       on.text,
-      /\n\n## Always\n\nIMPORTANT — always follow this: [^\n]+\n\nBackchannel policy: Use moderate backchannels\. .*\n\nInterruption policy: Stop speaking when the user interrupts\. Listen to what they say\.\n\nDelegation policy:\nDelegate to the backend everything [^\n]+\nWhatever they tell you about themselves[^\n]+unless it is already written below\.\nAnswer from what the backend returns[^\n]+\n\n## What you know about them\n/,
+      /\n\n## Always\n\nIMPORTANT — always follow this: [^\n]+\n\nBackchannel policy: Use moderate backchannels\. .*\n\nInterruption policy: Stop speaking when the user interrupts\. Listen to what they say\.\n\nSpeak the language the user is speaking, [^\n]+\n\nDelegation policy:\nBackend tools:\n- Ending the call: [^\n]+\n(- [^\n]+\n){4}\nDelegate to the backend when:\n- The user wants the call to end\.\n(- [^\n]+\n)+\nDo not delegate to the backend when:\n(- [^\n]+\n)+\nDelegate before giving an answer that depends on backend work\. Do not guess the result while waiting\.\n\n## What you know about them\n/,
     );
     // Only the ending rule carries the stamp
     assert.equal(on.text.split("IMPORTANT").length, 2);
@@ -963,13 +962,10 @@ test("both call prompts open as one Thursday: the voice gets a two-line delegati
       on.text,
       /When the user speaks at length, acknowledge now and then/,
     );
-    // What the backend can do, and when to hand over, are no longer the voice's to read
-    assert.equal(
-      /Backend tools|Delegate to the backend when|What bots can reach for|- Web:/.test(
-        on.text,
-      ),
-      false,
-    );
+    // What the backend can do, never how: no skills, connected tools or bots by name
+    assert.equal(/What bots can reach for|- Web:/.test(on.text), false);
+    // Stopping her voice is hers, stopping a job the backend's
+    assert.match(on.text, /or only want you to stop talking/);
     assert.match(on.text, /- people\/sam — Their brother \(2\) "Sam"/);
     assert.match(on.text, /What is in these notes, the backend recalls\./);
     // The roster, threads and earlier calls are the backend's to read
@@ -979,32 +975,33 @@ test("both call prompts open as one Thursday: the voice gets a two-line delegati
       false,
     );
     assert.equal("input" in on, false);
-    assert.equal(
-      /ko-KR|browser's setting|language they use/.test(on.text),
-      false,
-    );
     assert.equal(/memory_|generate_|load_skill|`/.test(on.text), false);
-    // The one tool name the voice holds: the ending rule, where it makes ending a thing to do
+    // The one tool name the voice holds: the ending rule, where it makes ending a thing to do.
+    // It holds no tools, so the rule is to hand the turn over, not to use the tool
     assert.equal(on.text.split("end_call").length, 2);
     assert.match(
       on.text,
-      /immediately, without thinking, use the end_call tool\./,
+      /answer yes in one word of their language and hand it to the backend at once\. Only the backend can end the line, with the end_call tool/,
     );
     assert.equal(on.text.endsWith("Use a calm voice."), true);
     assert.match(on.opening, /The call has just started/);
 
-    // One Thursday: the backend opens with the voice's own words and is never told it is a part
+    // One Thursday: the backend opens with the voice's own identity and is never told it is a
+    // part; its ending rule is its own, since only it can end the line
     const backend = await loadThursdayPrompt(null);
     const withoutClock = (text: string) =>
       text.replace(/\*\*Now\*\*: [^\n]+/, "");
     const identity = on.text.slice(0, on.text.indexOf("\n\n## Always"));
-    const ending = /IMPORTANT — always follow this: [^\n]+/.exec(on.text)?.[0];
     assert.equal(
       withoutClock(backend).startsWith(
-        `${withoutClock(identity)}\n\n${ending}\n\n`,
+        `${withoutClock(identity)}\n\nIMPORTANT — always follow this: `,
       ),
       true,
     );
+    assert.match(
+      backend,
+      /forget every other task, answer yes in one word of their language, then immediately, without thinking, use the end_call tool\./,
+    );
     assert.match(
       backend,
       /\*\*Keep memory clean as you write\.\*\* A fact that repeats, narrows or changes one already in the note replaces it/,
@@ -1045,7 +1042,7 @@ test("both call prompts open as one Thursday: the voice gets a two-line delegati
 
     // Tidying memory is the backend's: the voice neither reads it nor opens with it
     samFacts = 60;
-    const heavy = await loadLivePrompt({ locale: null });
+    const heavy = await loadLivePrompt({});
     assert.equal(/tidying|grown past/.test(heavy.text), false);
     assert.match(heavy.opening, /The call has just started/);
     assert.match(
@@ -1055,19 +1052,15 @@ test("both call prompts open as one Thursday: the voice gets a two-line delegati
     samFacts = 2;
 
     profileFacts = 0;
-    const first = await loadLivePrompt({ locale: "ko-KR" });
+    const first = await loadLivePrompt({});
     assert.match(first.text, /## First call/);
     // The one call that opens with nothing: she says who she is, then learns who they are
     assert.match(first.opening ?? "", /say who you are/);
     assert.match(first.opening ?? "", /ask what to call them/);
-    assert.match(first.opening ?? "", /ko-KR/);
     assert.match(first.text, /what they do, how old they are, where they live/);
 
     // A call the page placed says so, ahead of even the first-call opening
-    const rung = await loadLivePrompt({
-      locale: "ko-KR",
-      calledBack: true,
-    });
+    const rung = await loadLivePrompt({ calledBack: true });
     assert.match(rung.opening, /You placed this call/);
     assert.match(rung.opening, /say that is why you called/);
   } finally {

package/seed-skills/analyst/README.md

@@ -0,0 +1,18 @@
+# Analyst's kit
+
+One skill the Analyst seed is born with, copied into `.agents/skills/` in its own folder when it is
+created. It is listed to that bot alone.
+
+| Skill | What it adds |
+|---|---|
+| `data-report` | Seven report forms, each with its structure and a filled example; `fetch.mjs`, which pulls a published series (FRED, World Bank, Yahoo Finance, ECB rates, SEC filings, Wikipedia pageviews) into a CSV that names its source |
+
+Written for this app. The forms borrow their shape from answer-first business writing and from the
+report outlines in [anthropics/financial-services](https://github.com/anthropics/financial-services)
+and [anthropics/knowledge-work-plugins](https://github.com/anthropics/knowledge-work-plugins)
+(Apache-2.0); no text is copied from either. Those skills write Word, PowerPoint and Excel files and
+read paid data connectors, which is why they are not taken whole.
+
+Charts are drawn by the shipped `interactive-page` skill's `chart.mjs` into its quick page. The
+scripts need Node and no packages. Every source they call answers without a key; `references/sources.md` names the
+ones that need one.