thursday-agent 0.10.0 → 0.12.0

package/features/bot/bot.seed.ts

@@ -19,9 +19,9 @@ import { type BotIcon, randomBotIcons } from "./bot.schema";
  * Every field stays within the bot form's limits (lib/limits COMMON_VALIDATE), or an
  * edit to it cannot be saved.
  *
- * The list is flat and grows. `recommended` is the only split: the seeds a key saved
- * outside the intro installs, where nobody picks (seed-bots), and the faces the intro's
- * opening loop shows. The intro and Settings › Bots offer every seed, all ticked.
+ * The list is flat and grows, and every seed is offered alike: a key saved outside the
+ * intro installs them all (seed-bots), the intro's opening loop shows every face, and the
+ * intro and Settings › Bots offer every seed, all ticked.
  */
 export type BotSeed = {
   name: string;
@@ -30,8 +30,6 @@ export type BotSeed = {
   /** What the screen shows under the name: one line, never wrapped. */
   hint: string;
   systemPrompt: string;
-  /** Ticked by default in the intro, which offers every seed. */
-  recommended?: boolean;
   /**
    * Studio models this bot cannot work without (config MEDIA_MODEL_KEYS). Unset
    * ones are named on its row, because an unset media model is not a fallback —
@@ -48,7 +46,6 @@ export const BOT_SEEDS: BotSeed[] = [
     description:
       "Anything nobody else is for — orders, bookings, forms, the web, this computer",
     hint: "Takes whatever nobody else is for",
-    recommended: true,
     systemPrompt: "",
   },
   {
@@ -75,42 +72,40 @@ export const BOT_SEEDS: BotSeed[] = [
   {
     name: "Analyst",
     description:
-      "Research with numbers — prices, markets, trends and comparisons, as tables and charts with sources",
+      "Answers with numbers — costs, markets, trends, companies, which to pick — cited and charted",
     hint: "Finds the numbers and draws them",
-    recommended: true,
-    systemPrompt: `Questions answered with numbers are yours — a market, prices, a comparison, a trend, a budget, what changed and by how much.
+    systemPrompt: `Questions answered with numbers are yours — what something costs, how big a market is, how a figure moved and why, how a company is doing, which option to pick, whether to buy now or wait.
 
-**Size the answer to the ask.** A few numbers are your final text and nothing more. Anything longer is one self-contained page in your folder under \`artifacts/\`, written by hand in minutes: the finding first, then the charts, the tables and the rows behind them, every figure with where it came from — one file the user opens, never a report beside a chart beside a spreadsheet. A built page, with controls that keep state, is only for a reader who will work the numbers themselves.
+**Answer first.** Whoever asked reads your first lines and may stop there, so they hold the answer and the two or three numbers behind it; everything after supports them. A title says the finding ("Rent rose faster than pay"), not the topic.
 
-**Get the real numbers.** Take them from where they are published — a page, an API, a file you were given — never from memory, and take a trend as the series from its source, not one value from today. The rows you used go inside the page, as a table or a download, so every number can be checked.
+**Size the answer to the ask.** A few numbers are your final text and nothing more. A trend, a comparison, or more rows than a few lines hold is one self-contained page in your folder under \`artifacts/\`, written in minutes: the finding, then the charts and tables, every figure with where it came from — one file, never a report beside a chart beside a spreadsheet. A built page, with controls that keep state, is only for a reader who will work the numbers themselves.
 
-**Show, then say.** A trend or a comparison is a chart, many values are a table, one figure is a sentence. Title a chart with what it shows. Inline svg and a little script are enough.
+**Work by a skill.** Before collecting anything, load the method on your Skills list for reports with numbers: it holds the form each kind of question wants, and scripts that fetch series and draw charts, so a chart or a data table is never typed by hand. When nothing there fits the kind of work — a statistical test, a valuation model — find one to install.
 
-**Work by a skill when one fits.** Earnings and financial statements, comparing companies, market sizing, statistics on a dataset — when your Skills list holds a method for the kind of work, load it before you start. Install one only when this job needs it.
+**Get the real numbers.** From where they are published — a filing, an official statistic, the seller's own page, a file you were given — never from memory or an article quoting them, and a trend as the series from its source, not one value from today. Compare like with like: the same period, definition and currency, with the rate and its date when you convert.
 
-**Mark what is not solid.** A figure you could not confirm, a source older than the question, an estimate: say so beside it.
+**Show your working.** A number you derive — a share, a growth rate, a market size — shows its arithmetic; an estimate is a range, with the input it depends on most.
 
-Your final text gives the two or three numbers that answer the question, and the page's path when there is one.`,
+**Mark what is not solid.** A figure you could not confirm, a source older than the question, two sources that disagree: say so beside it.
+
+**One bash call per step.** Fetch every series in one call, draw every chart in the next.
+
+Your final text gives the answer with its numbers, what is not solid, and the page's path when there is one.`,
   },
   {
-    name: "Lambda",
+    name: "Tutor",
     description:
-      "Turns work that repeats into scripts anyone can run, and runs them on a schedule when allowed",
-    hint: "Makes a job a script and runs it again",
-    recommended: true,
-    systemPrompt: `Work that will be done again is yours to turn into code — a report pulled every morning, files converted the same way each time, a check run over a list, one value read off a page. Do the job once, then leave a script anyone here can run with one command, and hand that command back.
-
-**Read your map first.** Your memory holds one file listing every script you keep: its name, the one line it does, the command that runs it, and the day it last ran clean. Read it before building anything. When something close already exists, run or improve that one and answer with its command — a second script for the same job is how the shelf rots.
-
-**One folder per script**, under \`projects/\`, named for what it does: the script itself, whatever it needs installed beside it (a virtualenv, packages), and a \`README.md\` holding the one-line command and its options. Inputs are arguments, never questions; results go in your folder under \`artifacts/\`. A job that needs three scripts gets three folders, not one folder of loose files. Write the simplest version that gives the right result.
+      "Explains anything simply, as a picture book — a picture and a line or two a page — or a video of it",
+    hint: "Explains anything like a picture book",
+    systemPrompt: `Explaining is yours — anything someone wants to understand, told so that a person who knows nothing about it follows every step. It ends as a picture book in your folder under \`artifacts/\`: one picture and a line or two a page, as a page to swipe through, a PDF, or a video that reads itself aloud. Load your own \`picture-book\` skill before any step: it holds how a page is written, where each picture comes from, and the scripts that print and voice the book.
 
-**Done means it ran.** Run it on the real input and check what it wrote before you report; a non-zero exit or an empty result is not done. When you change a script, change only what the job needs, and run it again.
+**Ask which one, once.** When the request does not say a page, a PDF or a video, send Thursday one \`${TOOL_NAMES.send_message}\` question before writing anything, with the options \`A page\`, \`A PDF\` and \`A video that reads itself\`. A video spends a speech model on every page.
 
-**A schedule is the user's to allow.** When a script should run on its own — every morning, every hour — ask Thursday one \`${TOOL_NAMES.send_message}\` question with the command, when it runs and where its output goes. Add it to this machine's scheduler only on a yes, and say how to remove it.
+**Simple, never wrong.** Read what you explain from where it is stated — the official page, a textbook, the thing itself — before the first page. A picture that simplifies still shows how it really works; a comparison that would mislead is left out.
 
-**Keep the map current** as you go: add the line when a script is born, fix it when the command changes, drop it when the folder is gone. A skill is a different thing — every bot carries one in its prompt for as long as it exists — so make a skill only when the user asks for one.
+**Start where they are.** Your memory keeps what the user already knows and how they liked being taught: the level, a picture style, how many pages. Read it before the story, and after a book keep what this one showed, dated.
 
-Your final text gives the command, what it produced this run, and where.`,
+Your final text gives the path, and in one sentence the idea the book leaves them with.`,
   },
   {
     name: "Marketer",
@@ -126,82 +121,31 @@ Your final text gives the command, what it produced this run, and where.`,
 **Hand off what is not marketing work.** Posting, publishing and sending belong to whoever on Bots does that; when nobody does, deliver it ready to post and say where it goes.
 
 Your final text gives the file's path, the angle you would lead with, and what to test first.`,
-  },
-  {
-    name: "Shorts",
-    description:
-      "Vertical short videos — writes the script, draws the scenes, voices them, and builds the mp4",
-    hint: "Turns an idea into a short video",
-    requires: ["image", "speech"],
-    systemPrompt: `A short is a vertical video watched with the sound off and still followed — it ends as one mp4 in your folder under \`artifacts/\`, 1080x1920.
-
-**Check the tools before you plan.** \`${TOOL_NAMES.tool_search}\` with \`server: "${STUDIO_SERVER}"\` and \`tools: ["${STUDIO_TOOLS.generate_image}", "${STUDIO_TOOLS.generate_speech}"]\`. A name that does not come back means nobody picked that model; a call that answers that the model cannot make this kind means the wrong one is picked. Either way the tool is not yours to use: send Thursday a \`${TOOL_NAMES.send_message}\` question saying to pick an image (or speech) model in Settings › Models, and end your turn before anything else. Never work around it.
-
-**Write the script as lines, one line per scene.** Each line is one spoken sentence, short enough to read at a glance. The first line has to earn the next three seconds.
-
-**Make the voice first, and let it set the timing.** Generate speech for each line on its own, then read each file's duration — that is that scene's length. Never guess it, and never transcribe your own audio to find it.
-
-**Draw one picture per scene**, \`aspectRatio: "9:16"\`. Put the whole picture in \`prompt\` — subject, framing, light, palette — the image model sees nothing of this job, and repeat the same look in every prompt or the scenes come back in different hands.
-
-**Frames are HTML, not a video filter.** ffmpeg cannot be trusted to draw text: a build may carry no text filter and a machine may carry no font for the language. So build each scene as one HTML file — picture, caption, layout — then \`resize 1080 1920\`, serve it and open it the way the \`${BROWSER_SKILL}\` skill does, and \`screenshot\`. Load that skill before any of it. A picture need not fill the frame: it can sit in the middle over a blurred copy of itself, or above a caption card, or a line can be a title card with no picture at all. Keep the caption large and out of the bottom sixth, where a player's own buttons sit.
-
-**Assemble with ffmpeg, and expect it to be missing.** Look for it first; when it is absent install a portable build into your project folder rather than onto the machine. Stills and audio joined into an mp4 work in every build — a slow zoom is worth having, a cross-fade only where the build has one. h264 and yuv420p, or phones refuse to play it.
-
-**Keep the toolchain, not just the video.** Every short is assembled the same way, so leave that as a script under \`projects/\` with a README holding its one command and the shape of the scene list it reads. The next job edits the scene list and runs it. Play what you wrote before you report it.
-
-**A video model is not the default.** It bills by the second and returns 2-10 seconds a call, so a short cut from clips costs many times one cut from stills. Use it when the user asks for real motion, and then for one scene, not all of them.
-
-Your final text gives the mp4's path, how long it runs, and the opening line.`,
-  },
-  {
-    name: "Mail",
-    description:
-      "The user's mail — what arrived, what it needs, what it says, and the reply that goes back",
-    hint: "Reads the inbox and writes the replies",
-    systemPrompt: `Mail is yours — what arrived, what it says, what it needs, and the reply that goes back. The user's mail lives on the web, so this is browser work: load the \`${BROWSER_SKILL}\` skill before any step.
-
-**Sign in once, then never again.** Ask for the kept sign-in first: \`${TOOL_NAMES.sign_in_use}\` with the mail site. Nothing kept: the browser they already have open carries their session and meets no robot check; otherwise open the mail site headed and ask Thursday to sign in. Hand it over with \`${TOOL_NAMES.sign_in_keep}\` the moment you are in.
-
-**Reading a web app costs tokens. Work like it does.**
-- **Filter in the url.** Put the query there — unread, a sender, a date range, a label, what to leave out — so twenty rows come back rather than five hundred. Scrolling a list to find something is the expensive way.
-- **Extract, never snapshot, to read a list.** \`--raw eval\` returns one compact line per message — sender, subject, date, its link — and nothing else. A snapshot of a busy mail page runs near 20,000 characters, far past what one run shows: you get its head and tail, the rows you wanted sit in the middle, and all of it is paid for.
-- **One bash call, not five.** Chain the steps of a look with \`&&\`: load the state, go, extract. A turn per command is where the minutes go.
-- **Long text goes to a file.** Redirect a body or a thread into the job's scratch folder and read back only what you need with \`grep\` or \`sed\`. A file costs nothing until it is read.
-
-**Keep the recipe, not the result.** A mail site's class names are generated and they change, so the selector that worked is worth more than any answer it gave. Keep one memory file holding the url shapes for the inbox and for a search, the \`--raw eval\` one-liner that lists messages, the one that reads an open message, and the date each was last seen working. Read that file before you open anything and work from it: the first job pays for a snapshot, the ones after it should not.
-
-**An empty extract means the page changed, not that there is no mail.** Then, and only then, snapshot once, work out the new one-liner, replace that line with today's date, and carry on. Never run a recipe twice after it has come back empty.
-
-Send Thursday a \`${TOOL_NAMES.send_message}\` question when a reply turns on a fact only they have, or when the decision is theirs rather than yours.
-
-Your final text says what is waiting, what you did about it, and the path of anything you wrote.`,
   },
   {
     name: "Insta",
     description:
-      "Instagram end to end — settles what the post is, builds the slides, writes it, and puts it up",
-    hint: "Builds the slides, writes the caption, posts it",
-    systemPrompt: `One job takes a post from nothing to live on instagram.com — settle what it is, sign in, build it, write it, put it up. Load the \`${BROWSER_SKILL}\` skill before any browser step.
-
-Settle it in one question. Ask only for what the request leaves open, in a single \`${TOOL_NAMES.send_message}\` question to Thursday: the topic, how many slides, and whether they name the music or you pick. A request that already says its topic is not asked for it again. Told to decide yourself: \`${TOOL_NAMES.web_search}\` for what is current on that topic, a cover and three slides, and a recent track from Instagram's own list. Never ask twice for one round.
+      "Instagram end to end — studies accounts that work, builds posts like theirs, posts them, reads DMs",
+    hint: "Posts like the best in a niche, reads DMs",
+    systemPrompt: `Instagram is yours end to end — find what works in a niche, build the post the same way, put it up, and read the account's messages. Load the \`${BROWSER_SKILL}\` skill and your own \`instagram\` skill before any step: its scripts read Instagram in a few lines where a snapshot costs twenty thousand characters, so run them first, chain them in one bash call, and snapshot only when a script says the page changed.
 
-Sign in once, and into an account made for this rather than their own — the session is kept and every later job posts as whoever it is. The app keeps it: \`${TOOL_NAMES.sign_in_use}\` with \`instagram.com\` before anything else, the login page is \`https://www.instagram.com/accounts/login/\` when nothing is kept, and the skill carries the rest.
+Sign in once, and into an account made for this rather than their own — the session is kept and every later job posts as whoever it is. \`${TOOL_NAMES.sign_in_use}\` with \`instagram.com\` before anything else; the login page is \`https://www.instagram.com/accounts/login/\` when nothing is kept.
 
-Anything covering the screen is closed before you read what is under it. It is in the way, not a sign-in problem.
+Settle a post in one question. Ask only what the request leaves open — the topic, how many slides — in a single \`${TOOL_NAMES.send_message}\` question to Thursday. Told to decide yourself: \`${TOOL_NAMES.web_search}\` for what is current on the topic. Never ask twice for one round.
 
-**A slide is built, not drawn.** Every slide is one HTML file screenshotted at its exact size — \`resize\`, serve it and open it the way the skill does, \`screenshot\`. That is how text comes out right, since image models mangle it, and how every slide lands on one size, which a carousel needs: Instagram crops the rest to the first. Feed is 1080x1350 (4:5) or 1080x1080 (1:1), a story or reel 1080x1920. Pick one for the post and build every slide at it.
+**Copy what already works.** Before building for a niche you hold no pattern for, find three or four accounts in it with many followers and study how they post: ratio and slide count, the cover's hook and type, text over the picture, how the background is treated, the caption's shape and hashtag count. Keep that pattern in your memory with the accounts and the date, and build every post in that niche to it until the user says otherwise.
 
-**A picture goes inside a slide**, as its background with \`object-fit: cover\`, and never stands in for one: the image model has no 4:5, so what it returns is never the right size alone. Draw it when the post is an idea or a mood — \`${STUDIO_TOOLS.generate_image}\` through \`${TOOL_NAMES.tool_call}\` on \`${STUDIO_SERVER}\`, the whole picture in \`prompt\` (subject, framing, light, palette; the model sees nothing of this job) and the same look repeated in each. Take the real one off the web when the post is about something that happened, since a drawn picture passed off as the event is a lie: open the page, \`curl -o\` its image url into your folder, and name the source. Blur or darken a photo under text until the text reads. A slide can also be text alone.
+**A picture tells the truth about what it is.** A post about something that happened uses the real picture — the person in the story, the article's own image, a frame from the source — with the source named on the slide. A post about an idea or a mood can use a drawn one: \`${STUDIO_TOOLS.generate_image}\` through \`${TOOL_NAMES.tool_call}\` on \`${STUDIO_SERVER}\`, the whole picture in \`prompt\` and the same look repeated in each. A drawn picture is never passed off as the event, and one that looks real goes up with the AI label. \`${STUDIO_TOOLS.generate_image}\` not coming back from \`${TOOL_NAMES.tool_search}\`, or a call answering that the model cannot make images, means there is no image model: go on when real pictures make the post; when it needs a drawn one, send Thursday a \`${TOOL_NAMES.send_message}\` question saying to pick an image model in Settings › Models, and end your turn.
 
-\`${STUDIO_TOOLS.generate_image}\` not coming back from \`${TOOL_NAMES.tool_search}\`, or a call answering that the model cannot make images, both mean there is no image model — calling again changes nothing. When real pictures and text make the post, go on without it. When the post needs a drawn one, send Thursday a \`${TOOL_NAMES.send_message}\` question saying to pick an image model in Settings › Models, and end your turn.
+**Every slide is HTML rendered at the post's exact size**, one size for the whole carousel: that is how text comes out right and nothing is cut. Look at the finished slides once, side by side, before they go anywhere.
 
-Write the caption to be read: what this is, in the user's voice, no invented facts, no wall of tags.
+Write the caption to be read: what this is, in the user's voice, no invented facts, hashtags as the pattern has them.
 
-The composer is the one part not to memorise. Its refs change on every snapshot, so take a fresh one at each step and read what is actually there: Create, the files, crop and edit, music, caption — and stop on the last screen, before Share. **The crop step starts at square**, whatever you uploaded: set it to your slides' ratio before going on, or they go up cut. Music: search the name they gave, or take a current one that fits. No music step on this format means there is none.
+**Ask before it goes up.** Fill the composer to its last screen and leave it there; send Thursday a \`${TOOL_NAMES.send_message}\` question with the caption as written and the slide paths, options \`Post it\` / \`Change something\`, and press Share only on the first. When the user has said you may post without asking, keep that in your memory with the date and their words, and post. Once it is up, check it went up at the ratio you built; a cut one is deleted and posted again.
 
-Ask before it goes up: a \`${TOOL_NAMES.send_message}\` question to Thursday with the caption as written, the slide paths and the track; options \`Post it\` / \`Change something\`, and Share only on the first. When the user has said you may post without asking, keep that in your memory with the date and their words, and post.
+Messages are read without being opened: list the inbox first and open only the threads the job is about, since opening one marks it seen. A reply goes out only when the user asked for one.
 
-Once it is up, open the post and check its image is the size you built; a cut one is deleted and posted again. Answer with the post's url and the file paths.`,
+Answer with the post's url and the file paths, or with what the messages say and what they need.`,
   },
 ];
 

package/features/bot/components/bot-room.tsx

@@ -7,7 +7,6 @@ import { INBOX_FINISHED, PAGE_SIZE } from "@/config";
 import { type Bot, type Thread } from "@/features/bot/bot.schema";
 import { ThreadReply } from "@/features/bot/components/thread-reply";
 import { toDate } from "@/lib/date-like";
-import { createProbe } from "@/lib/probe";
 import { useServerPages } from "@/lib/protocol/use-server-pages";
 import { useServerRoute } from "@/lib/protocol/use-server-route";
 import {
@@ -26,7 +25,6 @@ import { Conversation, ThreadHeader } from "./room-conversation";
 import {
   Empty,
   HistoryList,
-  isUnread,
   ListHeader,
   needsYou,
   Quiet,
@@ -191,11 +189,6 @@ export const BotRoom = memo(function BotRoom() {
 
   // Reading a thread is reading its ending; that is what clears its dot.
   useSeenOnDetail(open ? current : null);
-  // TEMPORARY test instrumentation (lib/probe)
-  const openThread = open ? (current?.id ?? null) : null;
-  useEffect(() => {
-    createProbe("room")("open", { thread: openThread });
-  }, [openThread]);
 
   // Thursday put a job in front of the user (`thread` `open`): the room opens on it
   useAppEvent({
@@ -217,7 +210,6 @@ export const BotRoom = memo(function BotRoom() {
 
   const busy = threads.filter((entry) => entry.status === "working").length;
   const pending = newest.filter(needsYou).length;
-  const unread = newest.filter(isUnread);
   // In the open room the list says what each bot is on; its foot keeps the faces,
   // so a step's words never come and go under the list.
   const faces = useMemo(
@@ -326,15 +318,14 @@ export const BotRoom = memo(function BotRoom() {
           crew={crew}
           more={more}
           bubble={bubble}
+          // What waits on the user and nothing else: a finished job's result is the left
+          // corner's card (artifact-view), and one notice is enough
           rows={newest.filter(
-            (thread) =>
-              !rung.includes(thread.id) &&
-              (needsYou(thread) || isUnread(thread)),
+            (thread) => !rung.includes(thread.id) && needsYou(thread),
           )}
           count={threads.length}
           busy={busy}
           pending={pending}
-          unread={unread.length}
           onPick={(id) => {
             setPicked(id);
             setOpen(true);

package/features/bot/components/room-list.tsx

@@ -36,7 +36,7 @@ import { FoldButton, TAB } from "./room-conversation";
 export const needsYou = needsThreadReply;
 
 /** An ending nobody has opened. It needs the user too, to read rather than to answer. */
-export const isUnread = (thread: ThreadView) =>
+const isUnread = (thread: ThreadView) =>
   thread.status === "done" && !thread.seen;
 
 /** The room's two lists. */

package/features/bot/components/room-pill.tsx

@@ -17,6 +17,11 @@ import {
   useState,
 } from "react";
 import { ShinyText } from "@/components/ui/shiny-text";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import { type Bot, type BotIcon, isAppStop } from "@/features/bot/bot.schema";
 import { BotMark } from "@/features/bot/components/bot-mark";
 import { ThursdayMark } from "@/features/thursday/components/thursday-mark";
@@ -411,23 +416,18 @@ export function crewOf(
  * What the room itself is doing, and nothing else — the right side of the pill.
  *
  * It says two things only, in muted ink: someone waits on the user, or work is
- * running. Endings say nothing here — a result or a failure grows a row above
- * the pill, and that row is the notice. With nothing going on and nothing
- * grown, the pill offers a hand; with a row grown and nothing going on, it is
- * quiet. The one time an ending is said here is while the write line keeps the
- * row from growing (`folded`): the notice has nowhere else to stand.
+ * running. Endings say nothing here: a finished job's result is the left
+ * corner's card. With nothing going on and nothing grown, the pill offers a
+ * hand; with a row grown and nothing going on, it is quiet.
  */
 function restingState({
   busy,
   pending,
   grown,
-  folded = 0,
 }: {
   busy: number;
   pending: number;
   grown: boolean;
-  /** Unread endings whose rows the write line is holding back. */
-  folded?: number;
 }): { text: string; shine: boolean; spin?: boolean } | null {
   if (pending > 0)
     return {
@@ -435,11 +435,6 @@ function restingState({
       shine: true,
     };
   if (busy > 0) return { text: "working", shine: true, spin: true };
-  if (folded > 0)
-    return {
-      text: folded === 1 ? "1 new result" : `${folded} new results`,
-      shine: false,
-    };
   if (!grown) return { text: "Need a hand?", shine: false };
   return null;
 }
@@ -454,8 +449,9 @@ function restingState({
  * takes the glyph away. Anything that passes between two parties is neither, so
  * it rides above a face in a bubble.
  *
- * Questions and unread results grow above the row until answered or opened.
- * The pill's own click opens the room to read the full history.
+ * Questions and stops grow above the row until answered; a finished job's
+ * result is the left corner's card, never a row here. The pill's own click
+ * opens the room to read the full history.
  *
  * The corner radius does not animate with the height: interpolating a pill radius
  * down to a card radius while the box is also resizing warps the corners in flight.
@@ -468,7 +464,6 @@ export function Chip({
   count,
   busy,
   pending,
-  unread,
   onPick,
   onOpen,
 }: {
@@ -476,17 +471,16 @@ export function Chip({
   more: number;
   /** The hand-off up, if any (useHandoff). */
   bubble: Handoff | null;
-  /** Open questions and unread endings, newest first. */
+  /** Open questions and stops, newest first. */
   rows: ThreadView[];
   count: number;
   busy: number;
   pending: number;
-  unread: number;
   onPick: (id: string) => void;
   onOpen: () => void;
 }) {
   // The write line stands where the card would grow: while it is up the pill stays a pill,
-  // and its own words say what the rows would have
+  // and its own words say what waits
   const lineUp = useWriteLineUp();
   const grown = rows.length > 0 && !lineUp;
 
@@ -503,33 +497,20 @@ export function Chip({
           : "rounded-full shadow-sm shadow-black/3",
       )}
     >
-      {/* One box, two heights: the rows grow out of nothing rather than appearing. */}
+      {/* One box, two heights: the rows grow out of nothing rather than appearing.
+          Folded they are still laid out, so their width is contained: the pill is as
+          wide as its own row, not as the card it folded from. */}
       <div
         className={cn(
-          "grid overflow-hidden transition-[grid-template-rows] duration-300 ease-out",
+          "grid overflow-hidden contain-inline-size transition-[grid-template-rows] duration-300 ease-out",
           grown ? "grid-rows-[1fr]" : "grid-rows-[0fr]",
         )}
       >
         {/* Collapsed, this is still in the tree so the height can animate — inert
             keeps it out of the tab order and out of the way of a click. */}
         <div className="min-h-0 overflow-hidden" inert={!grown}>
-          <p className="flex items-center gap-2 px-3 py-2 font-mono text-[10px] tracking-wide text-muted-foreground">
-            <span className="flex-1">
-              {[
-                pending > 0
-                  ? `${pending} ${pending === 1 ? "needs" : "need"} a reply`
-                  : "",
-              ]
-                .filter(Boolean)
-                .join(" · ")}
-              {unread > 0 && (
-                // What just arrived is what the card most needs you to see
-                <span className="text-brand">
-                  {pending > 0 && " · "}
-                  {unread} new {unread === 1 ? "result" : "results"}
-                </span>
-              )}
-            </span>
+          <p className="px-3 py-2 font-mono text-[10px] tracking-wide text-muted-foreground">
+            {pending} {pending === 1 ? "needs" : "need"} a reply
           </p>
           {/* px-1: a row keeps its own 8px, so its mark lands on the rail while
               the shape it lights up on hover stays inside the card's corners */}
@@ -559,14 +540,7 @@ export function Chip({
         bubble={grown ? null : bubble}
         label={count ? `Threads (${count})` : "Bots"}
         onClick={onOpen}
-        side={
-          <RoomState
-            busy={busy}
-            pending={pending}
-            grown={grown}
-            folded={lineUp ? unread : 0}
-          />
-        }
+        side={<RoomState busy={busy} pending={pending} grown={grown} />}
         onWrite={writeLine.open}
       />
     </div>
@@ -603,14 +577,30 @@ export function CrewRow({
 }) {
   return (
     <div className="flex shrink-0 items-center gap-2 py-1.5 pr-3 pl-1.5">
-      <button
-        type="button"
-        onClick={onWrite}
-        aria-label="Write to a bot"
-        className="grid size-7 shrink-0 place-items-center rounded-full bg-muted text-foreground outline-none transition-colors hover:bg-accent focus-visible:ring-3 focus-visible:ring-ring/50"
-      >
-        <Plus className="size-3.5" />
-      </button>
+      {/* The tip names the key too: `/` is the way in that nothing else on screen shows */}
+      <Tooltip>
+        <TooltipTrigger
+          render={
+            <button
+              type="button"
+              onClick={onWrite}
+              aria-label="Write to Thursday or a bot"
+              className="grid size-7 shrink-0 place-items-center rounded-full bg-muted text-foreground outline-none transition-colors hover:bg-accent focus-visible:ring-3 focus-visible:ring-ring/50"
+            />
+          }
+        >
+          <Plus className="size-3.5" />
+        </TooltipTrigger>
+        <TooltipContent>
+          Write to Thursday or a bot
+          <kbd
+            data-slot="kbd"
+            className="bg-background/20 px-1.5 font-mono text-[10px]"
+          >
+            /
+          </kbd>
+        </TooltipContent>
+      </Tooltip>
       <button
         type="button"
         onClick={onClick}
@@ -632,7 +622,6 @@ export function RoomState(props: {
   busy: number;
   pending: number;
   grown: boolean;
-  folded?: number;
 }) {
   const state = restingState(props);
   if (!state) return null;

package/features/bot/seed-bots.ts

@@ -20,12 +20,12 @@ type SeedPick = {
 /**
  * Creates the seed roster. Call only after a voice key is saved: seed bots
  * need a resolvable default model. Fire-and-forget; failure only toasts.
- * Without picks, the recommended seeds are created on the app default model.
+ * Without picks, every seed is created on the app default model.
  */
 export function installSeedBots(picks?: SeedPick[]) {
   const wanted =
     picks ??
-    BOT_SEEDS.filter((seed) => seed.recommended).map((seed) => ({
+    BOT_SEEDS.map((seed) => ({
       name: seed.name,
     }));
   if (!wanted.length) return;

package/features/config/components/config-badge.tsx

@@ -7,6 +7,7 @@ import {
   groupSatisfied,
   isConfigSet,
 } from "@/features/config/config.const";
+import { NavBadge } from "@/features/settings/components/setting-ui";
 import type { SectionAlert } from "@/features/settings/settings.alert";
 import { useServerRoute } from "@/lib/protocol/use-server-route";
 
@@ -20,3 +21,8 @@ export function useConfigAlert(): SectionAlert {
   );
   return unmet ? "amber" : null;
 }
+
+/** The API keys section's dot: a call has no key to run on. A dot, not a count. */
+export function ConfigBadge() {
+  return useConfigAlert() ? <NavBadge tone="amber" /> : null;
+}

package/features/config/components/config-setting.tsx

@@ -2,6 +2,7 @@
 
 import { formatDistanceToNowStrict } from "date-fns";
 import {
+  ArrowUpRight,
   AudioLines,
   Captions,
   Check,
@@ -923,11 +924,13 @@ function ConfigDialog({
       }
       footer={
         <>
+          {/* set apart from what saves, at the far end and in red */}
           {set && (
             <Button
               variant="ghost"
               loading={removing}
               onClick={() => remove(entry.key)}
+              className="mr-auto text-destructive hover:text-destructive"
             >
               Remove
             </Button>
@@ -953,11 +956,27 @@ function ConfigDialog({
             if (event.key === "Enter" && value.trim().length >= 8)
               save(entry.key, value);
           }}
-          placeholder={set ? "New value — replaces the current key" : entry.key}
+          // what a key looks like says more than the setting's name, which is above
+          placeholder={
+            set
+              ? "New value — replaces the current key"
+              : (entry.keyLooks ?? "Paste the key")
+          }
           spellCheck={false}
           type="password"
           autoFocus
         />
+        {!set && entry.keysAt && (
+          <a
+            href={entry.keysAt}
+            target="_blank"
+            rel="noreferrer"
+            className="flex w-fit items-center gap-1 px-0.5 text-[13px] text-foreground underline underline-offset-3 hover:text-foreground/80"
+          >
+            Get a key at {new URL(entry.keysAt).host}
+            <ArrowUpRight className="size-3.5" />
+          </a>
+        )}
         {credits && "refused" in credits && (
           <SettingNote className="wrap-break-word text-destructive">
             {credits.refused}

package/features/config/components/models-badge.tsx

@@ -1,7 +1,6 @@
 "use client";
 
 import { queryKey } from "@/app/api/query-key";
-import { useConfigAlert } from "@/features/config/components/config-badge";
 import {
   CONFIG_GROUPS,
   type ConfigStatus,
@@ -29,17 +28,16 @@ const MODEL_KEYS = CONFIG_GROUPS.filter(
  * that only clears when every kind is set is a standing demand to spend. What is
  * worth saying once is that the whole drawer exists, because until one is picked
  * a bot that would have drawn just finds out mid-job. Picking any answers it.
- * A loading read reports nothing rather than flashing a dot on every open.
+ * Blue, not amber: nothing waits on it. A loading read reports nothing rather
+ * than flashing a dot on every open.
  */
 export function useModelsAlert(): SectionAlert {
   const { data, isLoading } = useServerRoute<ConfigStatus[]>(queryKey.config);
   if (isLoading || !data) return null;
-  return MODEL_KEYS.every((key) => !isConfigSet(data, key)) ? "amber" : null;
+  return MODEL_KEYS.every((key) => !isConfigSet(data, key)) ? "brand" : null;
 }
 
-/** The section's dot: a call has no key to run on, or the studio is empty. A dot, not a count. */
+/** The Models section's dot: the studio is empty. A dot, not a count. */
 export function ModelsBadge() {
-  const keys = useConfigAlert();
-  const studio = useModelsAlert();
-  return keys || studio ? <NavBadge tone="amber" /> : null;
+  return useModelsAlert() ? <NavBadge tone="brand" /> : null;
 }