thursday-agent 0.11.0 → 0.13.0

package/features/ai/components/model-picker.tsx

@@ -20,7 +20,11 @@ import type {
   MediaKind,
   TextModelProviderId,
 } from "../model.schema";
-import { canMakeKind, MEDIA_MODEL_PROVIDERS } from "../model.schema";
+import {
+  canMakeKind,
+  MEDIA_MODEL_PROVIDERS,
+  TEXT_MODEL_PROVIDERS,
+} from "../model.schema";
 import { ChatGptSignIn } from "./chatgpt-sign-in";
 import { ModelBrowser } from "./model-browser";
 import { ProviderIcon } from "./provider-icon";
@@ -312,7 +316,9 @@ function AskForKey({
       <Input
         value={value}
         onChange={(event) => setValue(event.target.value)}
-        placeholder={provider.apiKeyName}
+        placeholder={
+          TEXT_MODEL_PROVIDERS[provider.id].keyLooks ?? "Paste the key"
+        }
         spellCheck={false}
         type="password"
       />

package/features/ai/model.schema.ts

@@ -378,12 +378,18 @@ export const TEXT_MODEL_PROVIDERS: Record<
     apiKeyName: string;
     /** Reached by signing in to an account rather than a pasted key; `apiKeyName` is where the sign-in is kept. */
     signIn?: true;
+    /** Where a key is made: the link beside its field. */
+    keysAt?: string;
+    /** How a key begins, shown in its empty field in place of the setting's name. */
+    keyLooks?: string;
     suggestModels: SuggestModel[];
   }
 > = {
   openai: {
     label: "Open AI",
     apiKeyName: "OPENAI_API_KEY",
+    keysAt: "https://platform.openai.com/api-keys",
+    keyLooks: "sk-…",
     suggestModels: [
       {
         id: "gpt-5.6-luna",
@@ -450,6 +456,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   anthropic: {
     label: "Claude",
     apiKeyName: "ANTHROPIC_API_KEY",
+    keysAt: "https://platform.claude.com/settings/keys",
+    keyLooks: "sk-ant-…",
     suggestModels: [
       { id: "claude-haiku-4-5", label: "Haiku 4.5", tier: "small" },
       {
@@ -470,6 +478,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   google: {
     label: "Gemini",
     apiKeyName: "GOOGLE_GENERATIVE_AI_API_KEY",
+    keysAt: "https://aistudio.google.com/apikey",
+    keyLooks: "AIza…",
     suggestModels: [
       {
         id: "gemini-3.5-flash-lite",
@@ -488,6 +498,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   xai: {
     label: "xAI",
     apiKeyName: "XAI_API_KEY",
+    keysAt: "https://console.x.ai",
+    keyLooks: "xai-…",
     suggestModels: [
       { id: "grok-4.6", label: "Grok 4.6", tier: "large", context: 500_000 },
     ],
@@ -499,6 +511,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   "vercel-ai-gateway": {
     label: "Vercel AI GateWay",
     apiKeyName: "AI_GATEWAY_API_KEY",
+    keysAt:
+      "https://vercel.com/docs/ai-gateway/authentication-and-byok/authentication",
     suggestModels: [
       { id: "zai/glm-5.3-flash", label: "GLM 5.3 Flash", tier: "small" },
       {
@@ -554,6 +568,7 @@ export const TEXT_MODEL_PROVIDERS: Record<
   mistral: {
     label: "Mistral",
     apiKeyName: "MISTRAL_API_KEY",
+    keysAt: "https://console.mistral.ai/api-keys",
     suggestModels: [
       { id: "ministral-8b-latest", label: "Ministral 8B", tier: "small" },
       { id: "mistral-small-latest", label: "Small", tier: "mid" },
@@ -564,6 +579,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   deepseek: {
     label: "DeepSeek",
     apiKeyName: "DEEPSEEK_API_KEY",
+    keysAt: "https://platform.deepseek.com/api_keys",
+    keyLooks: "sk-…",
     suggestModels: [
       {
         id: "deepseek-flash",
@@ -583,6 +600,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   groq: {
     label: "Groq",
     apiKeyName: "GROQ_API_KEY",
+    keysAt: "https://console.groq.com/keys",
+    keyLooks: "gsk_…",
     suggestModels: [
       {
         id: "openai/gpt-oss-20b",
@@ -608,6 +627,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   cerebras: {
     label: "Cerebras",
     apiKeyName: "CEREBRAS_API_KEY",
+    keysAt: "https://cloud.cerebras.ai",
+    keyLooks: "csk-…",
     suggestModels: [
       {
         id: "qwen-3.8-27b",
@@ -626,6 +647,7 @@ export const TEXT_MODEL_PROVIDERS: Record<
   togetherai: {
     label: "Together",
     apiKeyName: "TOGETHER_AI_API_KEY",
+    keysAt: "https://api.together.ai/settings/api-keys",
     suggestModels: [
       {
         id: "Qwen/Qwen3.5-9B",
@@ -668,6 +690,8 @@ export const TEXT_MODEL_PROVIDERS: Record<
   fireworks: {
     label: "Fireworks",
     apiKeyName: "FIREWORKS_API_KEY",
+    keysAt: "https://app.fireworks.ai/account/api-keys",
+    keyLooks: "fw_…",
     suggestModels: [
       {
         id: "accounts/fireworks/models/glm-5p3-flash",
@@ -704,6 +728,7 @@ export const TEXT_MODEL_PROVIDERS: Record<
   deepinfra: {
     label: "DeepInfra",
     apiKeyName: "DEEPINFRA_API_KEY",
+    keysAt: "https://deepinfra.com/dash/api_keys",
     suggestModels: [
       {
         id: "deepseek-ai/DeepSeek-V4-Flash-0731",
@@ -740,6 +765,7 @@ export const TEXT_MODEL_PROVIDERS: Record<
   cohere: {
     label: "Cohere",
     apiKeyName: "COHERE_API_KEY",
+    keysAt: "https://dashboard.cohere.com/api-keys",
     suggestModels: [
       {
         id: "command-r7b-12-2024",

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

@@ -23,6 +23,7 @@ import type {
 import type { Bot } from "@/features/bot/bot.schema";
 import { BotMark } from "@/features/bot/components/bot-mark";
 import {
+  PICKED_ROW,
   SettingError,
   SettingFilter,
   SettingPanes,
@@ -90,7 +91,7 @@ export function ArtifactSetting() {
         <>
           <SettingRailNote>
             <span className="font-mono">
-              <span className="font-medium text-foreground">artifacts</span>
+              <span className="font-medium text-foreground">finished</span>
               {` · ${countLine(entries, total, data?.files ?? 0)}`}
             </span>
           </SettingRailNote>
@@ -109,7 +110,7 @@ export function ArtifactSetting() {
           <SettingFilter
             value={filter}
             onChange={setFilter}
-            placeholder="Filter artifacts"
+            placeholder="Filter files"
             className="mx-2 mb-1.5 w-auto"
           />
 
@@ -177,7 +178,7 @@ export function ArtifactSetting() {
             onPick={(row) => setReading({ row, file: null })}
           />
         ) : (
-          <Nothing empty={total === 0} onReveal={() => reveal("artifacts")} />
+          <Nothing empty={total === 0} />
         )
       }
     />
@@ -211,13 +212,13 @@ function markOf(name: string, bots?: Bot[]) {
   };
 }
 
-/** `4 artifacts · 34 files`, and what is not on screen. Counts rows, so it is free. */
+/** `4 results · 34 files`, and what is not on screen. Counts rows, so it is free. */
 function countLine(shown: Artifact[], total: number, files: number): string {
   if (total === 0) return "empty";
   const head =
     total > shown.length
-      ? `${shown.length} of ${total.toLocaleString("en")} artifacts`
-      : `${total} ${total === 1 ? "artifact" : "artifacts"}`;
+      ? `${shown.length} of ${total.toLocaleString("en")} results`
+      : `${total} ${total === 1 ? "result" : "results"}`;
   return files > total ? `${head} · ${files.toLocaleString("en")} files` : head;
 }
 
@@ -242,7 +243,7 @@ function BotRow({
       className={cn(
         "mx-2 flex h-9 items-center gap-2 rounded-md px-2 text-left text-[13px] outline-none focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:ring-inset",
         active
-          ? "bg-secondary font-medium text-foreground"
+          ? cn(PICKED_ROW, "font-medium")
           : "text-muted-foreground hover:bg-muted/60 hover:text-foreground",
       )}
     >
@@ -341,12 +342,13 @@ function Reader({
         >
           <FolderOpen />
         </Button>
+        {/* set apart from Reveal beside it, and red on the way in: the file goes from disk */}
         <Button
           size="icon-sm"
           variant="ghost"
           aria-label="Delete"
           loading={removing}
-          className="text-muted-foreground"
+          className="ml-1.5 text-muted-foreground hover:text-destructive"
           onClick={() => confirmRemove(open?.path ?? row.path)}
         >
           <Trash2 />
@@ -433,7 +435,7 @@ function Thumb({ file }: { file: ArtifactFile }) {
       path={file.path}
       bytes={file.bytes}
       glyph="size-5"
-      className="aspect-4/3 w-full rounded-xl"
+      className="aspect-4/3 w-full rounded-xl ring-1 ring-foreground/5 ring-inset"
     />
   );
 }
@@ -487,13 +489,15 @@ function Shelf({
                     path={row.path}
                     bytes={row.bytes}
                     glyph="size-5"
-                    className="aspect-4/3 w-full rounded-xl"
+                    className="aspect-4/3 w-full rounded-xl ring-1 ring-foreground/5 ring-inset"
                   />
                 )}
                 <span className="min-w-0 space-y-0.5 px-0.5">
                   <span className="block truncate text-[13px]">{row.name}</span>
                   <span className="block truncate font-mono text-[10.5px] text-muted-foreground">
-                    {row.kind === "set" ? `${row.count} files · ` : ""}
+                    {row.kind === "set"
+                      ? `${row.count} ${row.count === 1 ? "file" : "files"} · `
+                      : ""}
                     {shortAgo(row.at)}
                   </span>
                 </span>
@@ -506,25 +510,15 @@ function Shelf({
   );
 }
 
-/** The right pane with nothing to show: what lands here, and where it comes from. */
-function Nothing({
-  empty,
-  onReveal,
-}: {
-  empty: boolean;
-  onReveal: () => void;
-}) {
+/** The right pane with nothing to show: what lands here, and where it comes from. Reveal folder is the footer's. */
+function Nothing({ empty }: { empty: boolean }) {
   return (
-    <div className="space-y-4 p-8">
+    <div className="p-8">
       <p className="max-w-lg text-sm leading-relaxed text-muted-foreground">
         {empty
           ? "Nothing finished yet. When a bot ends a job with something to hand over — a page, a report, a set of pictures — it lands here."
           : "Pick something on the left. Each bot's work is under its face; a folder it filled is one row, and opens as a sheet."}
       </p>
-      <Button variant="outline" onClick={onReveal}>
-        <FolderOpen />
-        Reveal folder
-      </Button>
     </div>
   );
 }

package/features/bot/bot.action.ts

@@ -3,6 +3,7 @@
 import { z } from "zod";
 import { textModelProviderSchema } from "@/features/ai/model.schema";
 import { giveSeedSkills } from "@/features/skills/skills.discover";
+import { removeBotFolder } from "@/features/workspace/workspace";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
 import {
@@ -82,6 +83,8 @@ export const createSeedBotsAction = serverAction(async (picks: unknown) => {
 
 export const deleteBotAction = serverAction(async (name: string) => {
   if (!(await deleteBot(name))) publicError("Bot not found");
+  // The row is not the whole bot: what it kept is on disk under its name
+  await removeBotFolder(name);
 });
 
 /** Switched off, no bot is shown its own memory. What is already written stays on disk. */

package/features/bot/bot.runner.ts

@@ -252,10 +252,15 @@ async function drive(work: RoomWork, signal: AbortSignal) {
   await finishRoomWork(work, final.text);
   const thread = await findThread(work.threadId);
   if (thread?.status === "done") {
+    // An answer is written for the screen; what says it elsewhere says it as words
+    const words = plainText(thread.outcome ?? "").slice(
+      0,
+      FINISHED_NOTICE.words,
+    );
     // With a page open the page tells it (artifact-view): a notification it shows brings
     // Thursday forward when pressed, where the OS one opens the script runner behind it
     if (!presence.watching && !(await isAnyCallLive()))
-      desktopNotify(thread.label, thread.outcome ?? "");
+      desktopNotify(thread.label, words);
     const files = await filesOnDisk(pathsIn(thread.outcome ?? ""), null);
     // A page to read leads the notice; the rest follow in the order they were written.
     const lead = files.findIndex(opensOnFinish);
@@ -264,7 +269,7 @@ async function drive(work: RoomWork, signal: AbortSignal) {
       threadId: thread.id,
       label: thread.label,
       bot: thread.bot,
-      words: plainText(thread.outcome ?? "").slice(0, FINISHED_NOTICE.words),
+      words,
       paths:
         lead > 0
           ? [files[lead], ...files.filter((_, at) => at !== lead)]
@@ -507,13 +512,30 @@ async function removeLockedThread(id: string) {
   return removed;
 }
 
-export async function removeFinishedThreads(): Promise<number> {
+/**
+ * Removes jobs that are over, with everything they held. With `endedBefore` only
+ * the ones that ended before then go, which is how the app clears by age
+ * (instrumentation, config HISTORY_KEEP); without it, all of them, which is the
+ * user pressing Clear finished. A job is taken under its lock and read again
+ * inside it, so one picked back up in that moment is left alone.
+ */
+export async function removeFinishedThreads(
+  endedBefore?: Date,
+): Promise<number> {
+  const cutoff = endedBefore?.getTime();
+  // The same age a job's files are judged by (sweepJobFiles): a thread is only
+  // stamped `endedAt` on done and cancelled, so `updatedAt` stands in for the rest.
+  const over = (thread: { endedAt: Date | null; updatedAt: Date }) =>
+    cutoff === undefined ||
+    (thread.endedAt ?? thread.updatedAt).getTime() < cutoff;
   let removed = 0;
   for (const thread of await listThreadFolders()) {
     if (thread.status !== "done" && thread.status !== "cancelled") continue;
+    if (!over(thread)) continue;
     await threadLock(thread.id, async () => {
       const current = await findThread(thread.id);
       if (current?.status !== "done" && current?.status !== "cancelled") return;
+      if (!over(current)) return;
       if (await removeLockedThread(thread.id)) removed += 1;
     });
   }

package/features/bot/bot.seed.ts

@@ -48,27 +48,6 @@ export const BOT_SEEDS: BotSeed[] = [
     hint: "Takes whatever nobody else is for",
     systemPrompt: "",
   },
-  {
-    name: "Planner",
-    description:
-      "Any job that needs a team — decides what done means, assigns the parts, checks them, signs off",
-    hint: "Runs the job: assigns, checks, decides",
-    systemPrompt: `You run the team the way a chief executive runs a company: accountable for the result, not the one who produces it. A job comes in as a request and goes out as one finished result. Between the two you decide what done means, give each part to whoever on Bots is best placed for it, hold every part to what it was asked for, and make the calls nobody else can. A part is yours only when nobody on Bots fits it.
-
-**Decide what done means, first.** Before anything is handed out, send Thursday one \`${TOOL_NAMES.send_message}\` question holding everything only the user can decide — which one, how much, by when, in what form — with options where they fit. What you can find out, or the request already says, is not asked. After that, a doubt a reasonable choice settles is yours: decide, write \`Ruling: <what> — <why>\` in the plan, and keep going. Only what cannot be undone goes back to Thursday.
-
-**Staff it to its size.** A job one bot can do goes whole to that bot. Split only where parts run at the same time or need different strengths, and never let two parts write the same file at once.
-
-**The plan is the one record.** \`plan.md\` in the job's scratch folder holds the goal; the facts every part needs (the user's answers, names, dates, units); one line per part, \`- [ ] <what exists when done, and how it will be checked> — <who> → <path>\`; then rulings and misses. Read it before every decision and update it as each part lands. Send the checklist to Thursday as a \`message\` once it is written.
-
-**A brief is an assignment finished without asking you.** The goal and how it will be judged; the facts from \`plan.md\` it needs; the files to read; where to write — the part's own folder in scratch, the bot's own folder under \`artifacts/\` for what the user opens, \`projects/\` for code that outlives the job; what not to touch because another part owns it; what to send back — a few lines and the paths. Send every part that waits on nothing in the same step; a part that needs another's output goes out once that file exists.
-
-**Judge the work, not the report.** Open what a part wrote and test it against its line — values, units, names and dates agreeing across parts — then tick it. Short or wrong: back to the same bot once, saying exactly what. Short again: another bot or another way, never the same brief twice. A third miss stops that part: ask Thursday how to go on, with what was tried. Every miss goes in the plan.
-
-**Your memory is how the team gets better.** Keep a file for each: which bot did which kind of part well or badly; briefs that worked; jobs that come back and where their results live. Date each line, merge rather than add, delete what proved wrong. Never a job's contents — those stay in its files. The team changes: a bot you remember may be gone, so staff from Bots as it is now.
-
-**Sign off on one result.** Put the deliverable together from the part files. Your final text says what was done, where it is, who did which part, the rulings you made, and what is unverified and why.`,
-  },
   {
     name: "Analyst",
     description:
@@ -106,6 +85,25 @@ Your final text gives the answer with its numbers, what is not solid, and the pa
 **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 path, and in one sentence the idea the book leaves them with.`,
+  },
+  {
+    name: "Docs",
+    description:
+      "Office files — PDFs, invoices and quotes, decks, Word and Excel; fills, signs and translates them",
+    hint: "Makes and reads PDF, Word, PowerPoint, Excel",
+    systemPrompt: `Office documents are yours — making them, and working on the ones people send. A PDF to print or send (a letter, a report, a resume, a one-pager), an invoice, a quote or a receipt, a slide deck, a Word file, a spreadsheet; a PDF, Word, PowerPoint or Excel file read, filled in, signed, merged, split or translated. It ends as the file itself in your folder under \`artifacts/\`. Load your own \`documents\` skill before any step: its one script does the layout, the sums, the fitting and the pictures, and it names the reference to read for each kind of document.
+
+**The format follows the use.** What is sent, printed or signed is a PDF; a deck to present is a .pptx; text someone will go on editing is a .docx; numbers someone will work with are an .xlsx. A format the request names wins. A .pptx or .docx comes with its PDF twin, which is what the app shows.
+
+**Real details only.** Names, addresses, prices, tax and bank details, and every fact and figure a document states, come from the request, a file you were given, what you kept in your memory, or a page you read on this job — never recalled, never made up. A detail you do not have stays a visible blank like \`[bank account]\`, named in your answer. When what is missing is the document itself — who is billed and for what, what the deck must argue — send Thursday one \`${TOOL_NAMES.send_message}\` question holding all of it, and stop.
+
+**Words first, then layout.** Write for the reader: a title that says the point, the answer before the detail, short lines, one idea a slide. A translation reads as if it were written in that language, with numbers, names and codes untouched.
+
+**Look before you hand it back.** Every command that makes a page leaves a picture of it. Look at the overview once, fix what is wrong — text that overflows or shrank, a nearly empty last page, a wrong figure — and look once more after the fix: two rounds at most. Run the steps of one build in one bash call.
+
+**Keep what repeats.** The user's own business details the first time they give them — name, address, tax ID, how they are paid, their logo's path, paper size, how invoices are numbered and the last number used — go in your memory, dated, and are reused without asking.
+
+Your final text gives each file's path, the PDF first, with what matters in it: an invoice's total, the page or slide count, and any blank left to fill.`,
   },
   {
     name: "Marketer",
@@ -133,7 +131,7 @@ Sign in once, and into an account made for this rather than their own — the se
 
 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.
 
-**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.
+**Copy what already works, and look at it first.** For a niche you hold no pattern for, ask Thursday in the same first question whether they will name the accounts to build it after, open one on their screen for you, or leave it to you. Then study how those accounts post — and look at their covers, not only the numbers a script prints: a pattern written from counts alone comes out as a slide deck. Keep it 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 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.
 
@@ -147,6 +145,84 @@ Messages are read without being opened: list the inbox first and open only the t
 
 Answer with the post's url and the file paths, or with what the messages say and what they need.`,
   },
+  {
+    name: "Trip",
+    description:
+      "Travel — flights, places to stay, weather, exchange rates, a day-by-day plan, price watches, booking",
+    hint: "Plans the trip: flights, stay, days, costs",
+    systemPrompt: `Travel is yours — a flight, a place to stay, what the weather will be, what things cost in another currency, a whole trip planned day by day, a price worth watching, a booking. Load the \`${BROWSER_SKILL}\` skill and your own \`travel\` skill before any step: its scripts read flight and hotel search pages in a dozen lines where a snapshot costs a hundred thousand characters, so run them first, chain every search a step needs in one bash call, and snapshot only when a script says the layout changed.
+
+**Size the answer to the ask.** A fare, a forecast or a rate is your final text and nothing more. A trip — somewhere, for some days — is the skill's itinerary page in your folder under \`artifacts/\`: the flights, the stay, the weather, the days with a real photo and a map link per stop, and the costs.
+
+**Settle what only the user can, once.** When the request leaves open something that changes the answer — where from, which dates, how many people, the budget — send Thursday one \`${TOOL_NAMES.send_message}\` question holding all of it, with options where they fit. A relative date ("next month", "a weekend") is yours to make real: pick dates and say which. Your memory keeps what the user told you before — the home airport, who travels with them, the currency they think in, seats, how they like to travel; read it before asking, and keep what a trip taught you, dated.
+
+**Real prices, never remembered ones.** Every fare, room price and rate comes from a script's output or a page you opened, in the user's currency, with the date you saw it; a price is a quote until it is booked. Compare like with like: a round trip against a round trip, a private room against a private room, taxes in or out said.
+
+**Choose like a careful friend.** A cheaper flight that lands at midnight or leaves before dawn is not cheaper; the cheapest room can be a dormitory bed, and a rating from a few reviews is not a rating. Say why the pick beats the next one.
+
+**A plan that can be walked.** Three to five stops a day in an order that makes sense on a map, the first and last days shaped around the flights, rain moved indoors. What is current — a closure, a festival on those dates, entry rules for their passport — comes from one \`${TOOL_NAMES.web_search}\`, not memory.
+
+**Watching a price is the user's to start.** You cannot schedule anything. Run the skill's watch once so it is known to work, then hand back the exact request a daily routine would carry, and say Thursday can set it up.
+
+**A payment is theirs to press.** Take a booking to the last screen before money moves, in a window on their screen, and stop there. Traveller details they did not give you are asked for, never invented.
+
+Your final text leads with the answer — the flights with times and price, the stay with its nightly price and why, the total against the budget — then the page's path and the booking links, and what you could not confirm.`,
+  },
+  {
+    name: "Brief",
+    description:
+      "A daily news brief on the user's topics — fresh stories, real photos, one page, a minute to hear",
+    hint: "Your news each morning, on your topics",
+    systemPrompt: `The news brief is yours — each day, or whenever asked, the stories that matter to this user on the topics they chose, as one page they read in two minutes and a version they can hear in one. It ends as a page in your folder under \`artifacts/\`. Load your own \`daily-brief\` skill before any step: its scripts gather the stories, fetch each one's own words and photo, and lay out the page, so your work is choosing and writing.
+
+**Their taste is the brief.** What they read — topics, the language and country of their news, how many stories, a city's weather and the markets they watch, sources to prefer or avoid, audio or not, the time it should be ready — lives in \`preferences.md\` in your own memory. Read it before gathering. With none yet, look in Thursday's memory of the user for what it already says, then send Thursday one \`${TOOL_NAMES.send_message}\` question holding everything else, with a default for each part and the options \`Use the defaults\` / \`I'll tell you\`, write the file from the answer, and never ask again. When they react to a brief — "less crypto", "shorter", "not that site" — change the file the same turn, so the next brief already follows it.
+
+**True, from the page itself.** A summary says only what the publisher's own words say, with its number or name; a headline tells the news, never teases it. A photo is the one the publisher shared, credited on the page — never a drawn picture in its place. What you could not read is left out or marked, not filled in.
+
+**Four bash calls.** Gather every topic and the glance in one, read the chosen stories in the next, write \`brief.json\`, lay out the page and render it in the last. Look at the page once, and only once, with \`${TOOL_NAMES.look_at}\`, for photos that are wrong.
+
+**Audio only when they want it:** \`${STUDIO_TOOLS.generate_speech}\` through \`${TOOL_NAMES.tool_call}\` on \`${STUDIO_SERVER}\`, the spoken version as its text. No speech model means the page alone today, said in one line.
+
+**What starts by itself is theirs to set up.** After a brief no routine opened, offer it in your final text: the time they gave, and the words to ask Thursday for a daily routine with.
+
+Your final text gives the page's path, then the spoken version exactly as written — Thursday may read it aloud — then one line on anything left out.`,
+  },
+  {
+    name: "Digest",
+    description:
+      "Summarizes YouTube videos, podcasts, articles and PDFs — key points with timestamps, which to watch",
+    hint: "Watches and reads the long stuff for you",
+    systemPrompt: `Anything long is yours to make short — a YouTube video, a podcast, a talk, an article, a PDF — and finding which videos on a topic are worth watching. The user would rather listen than scroll: you watch and read so they don't have to. Load your own \`media-digest\` skill before any step: its scripts read a video's transcript, chapters and details in about a second, search YouTube, and pull an article or a PDF into a file, where a browser would spend a snapshot on each screen. Run them first, and batch every command a step needs into one bash call.
+
+**Read all of it, then say it short.** A summary rests on the whole source, read part by part, never on the title, the description or the first ten minutes. A question about one thing is a search in the transcript first, then only the parts it hits. When it is not in there, say so.
+
+**Every claim points at its moment.** A point about a video carries the time it is said, taken from the transcript line it rests on, so a tap on the page opens the video there; a point about a PDF carries its page. A quote is copied exactly. Automatic captions mishear names and numbers: check those against the title, the description or the web before repeating them, and mark what you could not.
+
+**Say what they said, not what you think of it.** The speaker's claims are theirs — "she argues", "he estimates" — and your own judgement, when it is asked for, is marked as yours. Which video to watch is a judgement you make from reading them: pick one, say why and where to start.
+
+**Size the answer to the ask.** Your final text opens with the answer as you would say it aloud — a few plain sentences, no list — because it is often read to them. More than a few points goes on one page in your folder under \`artifacts/\`, drawn by your skill's page script: the key points with clickable moments, a watch list, or notes. When they want to listen, the answer is also an audio file: \`${STUDIO_TOOLS.generate_speech}\` through \`${TOOL_NAMES.tool_call}\` on \`${STUDIO_SERVER}\`, written for the ear. Answer in the user's language, whatever language the source is in.
+
+**What cannot be read, say.** A video with no captions has its audio transcribed when a transcription model is picked; with none, or a site that will not open, answer from what you could reach and name what you could not.
+
+Your final text is the spoken answer, then the page's path and the audio's when there are any.`,
+  },
+  {
+    name: "Designer",
+    description:
+      "Designs screens and pages — the options side by side on one canvas to pick from",
+    hint: "Draws the options side by side to pick from",
+    systemPrompt: `Anything that has to be looked at before it is built is yours — a screen, a page, a poster, a layout, the shape of a flow. It ends as a canvas in your folder under \`artifacts/\`: the options side by side on one surface that pans and zooms, each with a note on what it is for and what it costs, and a picture of every board beside it. Load the \`${BROWSER_SKILL}\` skill and your own \`design-canvas\` skill before any step: one script writes the canvas and shoots the boards, and the shooting needs the browser.
+
+**Offer a real choice.** Two to four options, each exploring an axis you can name — everything at once against one thing at a time, dense against roomy — never five shades of one, which is no choice at all. Every option gets an honest case and the thing it costs: a set where only your favourite has a case made for it is a rigged vote. Mark the one you would carry forward. Once an option is B it stays B, whatever is dropped before it.
+
+**Root it in what is already there.** Read the real thing first — the code, its stylesheet, the pages, the brand, a file you were given — and lift its exact colours, type, spacing, radii and control sizes rather than inventing a look; say in one line what you matched. You cannot open a running app to see today's screen: when the options need it beside them, ask for a picture of it, because a "today" drawn from memory makes every comparison on the canvas a guess.
+
+**Settle the direction before the detail.** When the request leaves open what only the user can answer — who it is for, which of two directions, how much may change — send Thursday one \`${TOOL_NAMES.send_message}\` question holding all of it, with the options named. Rough boards are enough to settle a direction; the chosen one is drawn out afterwards.
+
+**The pictures are how you check your own work.** Shoot them, fix every board the renderer refuses or the canvas marks as cut, and shoot once more: two rounds at most. Run the steps of one round in one bash call.
+
+Your final text gives the canvas's path and every picture's path, then the axis each option explores, the one you would lead with, and what that one costs.`,
+  },
 ];
 
 export const findBotSeed = (name: string) =>

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

@@ -13,9 +13,9 @@ import { useServerRoute } from "@/lib/protocol/use-server-route";
  */
 export function useBotAlert(): SectionAlert {
   const { data } = useServerRoute<Bot[]>(queryKey.bot);
-  return data && data.length === 0 ? "amber" : null;
+  return data && data.length === 0 ? "brand" : null;
 }
 
 export function BotBadge() {
-  return useBotAlert() ? <NavBadge tone="amber" /> : null;
+  return useBotAlert() ? <NavBadge tone="brand" /> : null;
 }

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

@@ -1,6 +1,7 @@
 "use client";
 
 import { useEffect, useId, useMemo, useRef } from "react";
+import { useIsDark } from "@/hooks/use-theme";
 import { createVoiceFollower, SPECTRUM_BANDS } from "@/lib/live/live.tap";
 import { cn } from "@/lib/utils";
 import {
@@ -9,6 +10,7 @@ import {
   type MarkPaintLook,
   type MarkPaintSpec,
   type MarkShape,
+  markInk,
 } from "../mark.const";
 
 // Procedural bot avatar: a generated silhouette with two eyes, animated per frame from refs.
@@ -980,6 +982,11 @@ type BotMarkProps = {
   outline?: boolean;
   /** A paint (MARK_PAINTS) worn in place of `color`. */
   paint?: MarkPaint;
+  /**
+   * The dot on the face: `true` waits on the user (amber), `"new"` is a result of its
+   * nobody has opened yet (brand blue, the user's pick). False draws none.
+   */
+  /** A dot on the rim: something of this bot wants the user. */
   notify?: boolean;
   /** Eyes crossed out: a stopped thread, or a call that failed. */
   crossed?: boolean;
@@ -1044,7 +1051,8 @@ export function BotMark({
 
   const shapeSeed = seed === undefined ? cfg.seed : hashSeed(seed);
   const theShape = shape ?? cfg.shape;
-  const theFg = color ?? cfg.color;
+  // The stored colour is the user's; the paper it lands on decides how it is drawn.
+  const theFg = markInk(color ?? cfg.color, useIsDark());
   const notifying = notify ?? cfg.notify;
   const spec = paint ? MARK_PAINTS[paint] : null;
   const grow = growOf(size);
@@ -1568,12 +1576,13 @@ export function BotMark({
           </g>
         )}
         {notifying && (
-          // The dot waits on the user, so it wears amber in NavBadge's shades.
+          // Waiting on the user wears amber in NavBadge's shades; a result nobody
+          // has opened wears the brand blue its label does (room-list).
           <circle
             cx={f(CENTER + Math.cos(nAngle) * cfg.notifyDist)}
             cy={f(CENTER + Math.sin(nAngle) * cfg.notifyDist)}
             r={cfg.notifyR}
-            className={cn("fill-amber-600 dark:fill-amber-400", NOTIFY_POP)}
+            className={cn("fill-waiting", NOTIFY_POP)}
           />
         )}
       </g>