thursday-agent 0.10.0 → 0.11.0

package/features/ai/prompts/live.prompt.ts

@@ -1,3 +1,4 @@
+import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import {
   listAlwaysLoaded,
   listNoteIndex,
@@ -10,7 +11,6 @@ import {
   type MemoryNoteView,
 } from "@/features/memory/memory.schema";
 import {
-  callEnding,
   carriedLines,
   expandedFacts,
   logPromptSize,
@@ -21,16 +21,15 @@ import {
 
 /**
  * Everything the Live voice hears: who Thursday is and how a call ends (the words the backend
- * opens with too), the guide's starter backchannel and interruption policies, a two-line
- * delegation policy, and what she knows about the user. What the backend can do, how work is
- * handed over, earlier calls and tidying memory are the backend's (thursday.prompt): the voice
- * hands everything but conversation over and answers from what comes back. Assembled on every
- * call, never cached.
+ * opens with too), the guide's starter backchannel and interruption policies, its delegation
+ * policy (what the backend can do, when to hand over and when not), and what she knows about
+ * the user. How the work is done, earlier calls and tidying memory are the backend's
+ * (thursday.prompt): the voice hands everything but conversation over and answers from what
+ * comes back. Assembled on every call, never cached.
  */
 export async function loadLivePrompt(options: {
   /** Settings › Thursday › Voice instructions; added to, never replacing, what is below. */
   voicePrompt?: string | null;
-  locale?: string | null;
   /** The page placed this call because background work waits on the user (call-back). */
   calledBack?: boolean;
   /** The last call is in the conversation ahead of the opening (call-last). */
@@ -45,11 +44,6 @@ export async function loadLivePrompt(options: {
 
   const first = !open.notes.find((note) => note.path === "profile")?.facts
     .length;
-  // Only the first-call greeting reads it: before they have said anything, the
-  // browser's locale is the one sign of their language
-  const language = options.locale
-    ? `the language of \`${options.locale}\`, their browser's setting`
-    : "the language they use";
 
   const text = [
     thursdayIdentity(),
@@ -69,7 +63,7 @@ export async function loadLivePrompt(options: {
     opening: options.calledBack
       ? "You placed this call because background work has something for the user; it comes in next. Speak first: greet them in one line and say that is why you called."
       : first
-        ? `Open the call now, in ${language}: say who you are and what you are here to do for them, in a line or two, then ask what to call them. Then stop and listen.`
+        ? "Open the call now: say who you are and what you are here to do for them, in a line or two, then ask what to call them. Then stop and listen."
         : options.remembers
           ? "The call has just started. Speak first: greet the user naturally, in one line, as someone who remembers the last call."
           : "The call has just started. Speak first: greet the user naturally, in one line.",
@@ -79,40 +73,71 @@ export async function loadLivePrompt(options: {
 /**
  * The rules for every turn, together right under the identity, where the model weighs most.
  * One heading marks them; `IMPORTANT` stays on the ending rule alone, the one that failed
- * without it (09-17), so stamping it on all four would thin it out.
+ * without it (09-17), so stamping it on all of them would thin it out.
  */
 const always = () => `## Always
 
-${callEnding()}
+${ending()}
 
 ${speaking()}
 
 ${delegation()}`;
 
+/**
+ * How a call ends, as the voice can end it: it holds no tools, so it says yes and hands the turn
+ * over, and the backend runs the tool. The rule both prompts shared until 09-20 ("forget every
+ * other task, answer yes, then use the tool") left the voice saying yes and going quiet with the
+ * line still open, four times in five. The tool is still named, the one name the voice sees, so
+ * ending reads as something done rather than said.
+ */
+const ending = () =>
+  `IMPORTANT — always follow this: when the user wants the call to end, however they say it, 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 ${TOOL_NAMES.end_call} tool; saying yes alone leaves it open.`;
+
 /**
  * The guide's starter lines on listening and interruptions, labels kept as it says. The
  * backchannel line is the one it invites changing: a long turn heard in silence reads as
- * nobody listening.
+ * nobody listening. The language is the one being spoken, never the browser's: a first call
+ * opened in the browser's language kept an English speaker in Korean.
  */
 function speaking(): string {
   return `Backchannel policy: Use moderate backchannels. When the user speaks at length, acknowledge now and then with a short listening sound so they know you are following, without competing with the main response.
 
-Interruption policy: Stop speaking when the user interrupts. Listen to what they say.`;
+Interruption policy: Stop speaking when the user interrupts. Listen to what they say.
+
+Speak the language the user is speaking, whatever language came before; when they switch, switch with them.`;
 }
 
 /**
- * Under the guide's label, and no longer than this: Live decides for itself whether to hand a
- * turn over, and with no rule it answered from its own knowledge or only said it would act.
- * What the backend can do and how is the backend's to know. What they say about themselves is
- * named on its own: nothing is kept that is not handed over, and it is rarely a request. The
- * voice sees only profile and preferences whole, so "already written" is a rough filter; the
- * backend merges the rest (thursday.prompt memory).
+ * The guide's three labels, as it asks: Live decides for itself whether to hand a turn over,
+ * and reads that from what the list says the backend can do. Without the list (09-17 to 09-19)
+ * it said "yes" to a hang-up, a stop or a routine and handed nothing over: 1 `end_call` in 21
+ * calls, then none in 34, where the list had drawn 5 in 7. The list names what can be done,
+ * never how: tools, bots and threads stay the backend's. What they say about themselves is
+ * its own line: nothing is kept that is not handed over, and it is rarely a request. The voice
+ * sees only profile and preferences whole, so "already written" is a rough filter; the backend
+ * merges the rest (thursday.prompt memory). Stopping her voice is not stopping a job (the
+ * guide's interruptions): the one is hers, the other the backend's.
  */
 function delegation(): string {
   return `Delegation policy:
-Delegate to the backend everything the user asks for, tells you or asks about, except greetings, small talk and a brief clarification.
-Whatever they tell you about themselves, the people in their life, their plans or how they want things done goes to the backend as they say it, however small — unless it is already written below.
-Answer from what the backend returns, and do not guess the result while waiting.`;
+Backend tools:
+- Ending the call: hangs up the line.
+- Background work: hands a job to a bot, passes words on, stops or changes a job, answers a bot's question, says how the work stands.
+- Routines: jobs that start by themselves later.
+- Memory: keeps what the user tells you about themselves, and looks it up.
+- This computer and the web: runs a command, searches.
+
+Delegate to the backend when:
+- The user wants the call to end.
+- They ask for anything on that list, or change or stop work already asked for.
+- They tell you about themselves, the people in their life, their plans or how they want things done, however small, unless it is already written below.
+
+Do not delegate to the backend when:
+- They greet you, make small talk, or only want you to stop talking.
+- You can answer from the conversation or a result still current.
+- You need a brief clarification to understand the request.
+
+Delegate before giving an answer that depends on backend work. Do not guess the result while waiting.`;
 }
 
 /**

package/features/ai/prompts/prompt-helper.ts

@@ -22,7 +22,7 @@ import { clip } from "@/lib/utils";
 /**
  * Row-to-line formatters shared by the call prompts (live, thursday) and bot.prompt, plus the tidying check.
  * Nothing here wraps a sentence; headings and paragraphs live in the prompt that says them. The
- * exceptions are `thursdayIdentity` and `callEnding`, the words both call prompts open with.
+ * exception is `thursdayIdentity`, the words both call prompts open with.
  */
 
 /**
@@ -85,14 +85,6 @@ export const thursdayIdentity = (now = new Date()) =>
 
 What they tell you is kept, so you know them better over time, and whatever they want done can be done for them in the background.`;
 
-/**
- * How a call ends, in the same words right after the identity in both call prompts. It names
- * the tool in both, the one tool name the voice sees: without it, ending the call read as
- * something to say rather than do, and the line stayed open through repeated requests.
- */
-export const callEnding = () =>
-  `IMPORTANT — always follow this: when the user wants the call to end, however they say it, forget every other task, answer yes in one word of their language, then immediately, without thinking, use the ${TOOL_NAMES.end_call} tool.`;
-
 /**
  * When a call happened, the one way every prompt and tool says it: local, the
  * same shape as `Now` (clockNow), with how long ago. A UTC stamp beside a local

package/features/ai/prompts/thursday.prompt.ts

@@ -28,7 +28,6 @@ import {
 import { openWorkspace } from "@/features/workspace/workspace";
 import { listConnectedToolNames } from "../tools/connected";
 import {
-  callEnding,
   carriedLines,
   expandedFacts,
   logPromptSize,
@@ -88,7 +87,7 @@ export async function loadThursdayPrompt(
   // Order matters: earlier calls go last so the current call follows them in time order
   const text = [
     thursdayIdentity(),
-    written ? "" : callEnding(),
+    written ? "" : ending(),
     memory(index, carried, open.notes),
     // A skill is named once, on the side that can read it: this computer's chapter
     // when the setting hands the call the tool, the bots' reach when it does not
@@ -110,6 +109,13 @@ export async function loadThursdayPrompt(
   return text;
 }
 
+/**
+ * How a call ends, right after the identity. Only the backend can end the line, so its rule is
+ * to do it at once, with the tool named; the voice's own rule (live.prompt) is to hand it over.
+ */
+const ending = () =>
+  `IMPORTANT — always follow this: when the user wants the call to end, however they say it, forget every other task, answer yes in one word of their language, then immediately, without thinking, use the ${TOOL_NAMES.end_call} tool.`;
+
 /**
  * What goes back is said aloud, so it is what a tool or a note confirmed and nothing more — or
  * the one question the voice puts to the user before work is handed over (backgroundWork).

package/features/bot/bot.run.ts

@@ -30,6 +30,7 @@ import {
   type JobBot,
   type TokenUsage,
 } from "@/features/bot/bot.schema";
+import { renewSignIns } from "@/features/signins/signins.query";
 import {
   botBrowserSession,
   filesOnDisk,
@@ -154,6 +155,9 @@ export async function runBot(
       : null,
     openBotFolders(name),
   ]);
+  const session =
+    options.session ??
+    (options.threadId ? botBrowserSession(options.threadId, name) : null);
   const [prompt, tools] = await Promise.all([
     loadBotPrompt(
       name,
@@ -170,9 +174,7 @@ export async function runBot(
       target: "bot",
       bot: name,
       thread: options.threadId ?? null,
-      session:
-        options.session ??
-        (options.threadId ? botBrowserSession(options.threadId, name) : null),
+      session,
       model,
     }),
   ]);
@@ -474,6 +476,10 @@ export async function runBot(
     quiet.end();
     acknowledgeStep();
     await Promise.allSettled([...inFlight]);
+    if (session)
+      void renewSignIns(session).catch((cause) =>
+        logger.warn(`${name}: kept sign-ins were not renewed`, cause),
+      );
   }
 
   try {

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 {
@@ -191,11 +190,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({

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

@@ -503,10 +503,12 @@ 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]",
         )}
       >

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/intro/components/intro.tsx

@@ -823,7 +823,6 @@ function useDemo(playing: boolean) {
 
 /** The pill and the corner where finished work lands, as they stand during the loop. */
 function DemoCorners({ stage, icons }: { stage: DemoStage; icons: BotIcon[] }) {
-  const crew = BOT_SEEDS.filter((seed) => seed.recommended);
   return (
     <>
       {/* The card finished work really lands as, drawn here with nothing behind it */}
@@ -843,12 +842,12 @@ function DemoCorners({ stage, icons }: { stage: DemoStage; icons: BotIcon[] }) {
       )}
       <div className="absolute right-5 bottom-5 flex h-10 items-center gap-2.5 rounded-full bg-background pr-3.5 pl-2.5 ring-1 ring-border">
         <span className="flex">
-          {crew.map((seed, index) => (
+          {BOT_SEEDS.map((seed, index) => (
             <BotMark
               key={seed.name}
               size={22}
               seed={seed.name}
-              {...icons[BOT_SEEDS.indexOf(seed)]}
+              {...icons[index]}
               state={
                 stage === "working" && seed.name === "Analyst"
                   ? "thinking"

package/features/reach/reach.ts

@@ -2,6 +2,7 @@ import { readFile, stat } from "node:fs/promises";
 import type { ModelMessage } from "ai";
 import { appEvents } from "@/app/api/events/app-event.server";
 import { REACH } from "@/config";
+import { LiveSettingsSchema } from "@/features/ai/live.schema";
 import { modelErrorToString } from "@/features/ai/model";
 import { answerThread } from "@/features/bot/bot.runner";
 import type { Thread } from "@/features/bot/bot.schema";
@@ -14,7 +15,6 @@ import {
 } from "@/features/config/config.query";
 import { openWork } from "@/features/thursday/open-work";
 import { endCall, isCallOpen } from "@/features/thursday/thursday.query";
-import { ThursdaySettingsSchema } from "@/features/thursday/thursday.schema";
 import {
   answerInWriting,
   openTextCall,
@@ -353,7 +353,7 @@ async function answer(
     4_000,
   );
   try {
-    const settings = ThursdaySettingsSchema.parse({});
+    const settings = LiveSettingsSchema.parse({});
     // Quiet for long enough, or closed under it (the tab went, the server restarted): the
     // next words open a new call, which reads the last one back under Earlier calls
     const kept = live.line;