thursday-agent 0.2.0 → 0.3.0

package/features/bot/bot.schema.ts

@@ -64,6 +64,9 @@ export type TokenUsage = z.infer<typeof TokenUsageSchema>;
 
 export const NO_TOKENS: TokenUsage = { input: 0, output: 0 };
 
+/** A budget under this leaves no room for the opening message, so it is refused rather than stored. */
+export const COMPACT_AT_MIN = 8_000;
+
 export const BotSchema = z.object({
   name: z.string(),
   description: z.string(),
@@ -72,15 +75,16 @@ export const BotSchema = z.object({
   /** Set only when chosen; empty runs on the app default model. */
   provider: textModelProviderSchema.nullish(),
   model: z.string().nullish(),
+  /** Where this bot's runs compact; empty derives it from the model's own window. */
+  compactAt: z.number().nullish(),
+  /** Switched off by the user: kept whole, shown to no model. */
+  disabled: z.boolean(),
   createdAt: DateLikeSchema,
   tools: PinnedToolSchema.array().default([]),
   /** Sum over every job this bot ran; deleted jobs drop out. */
   tokens: TokenUsageSchema,
   /** When this bot's latest job last moved; null if it never ran. Carried here so the roster need not page through history. */
   lastJobAt: DateLikeSchema.nullish(),
-  /** The bot's own notes, written by itself at report time. Shown, never edited; the user's only move is to clear them. */
-  note: z.string().nullish(),
-  noteAt: DateLikeSchema.nullish(),
 });
 
 export const BotFormSchema = z.object({
@@ -95,6 +99,13 @@ export const BotFormSchema = z.object({
   /** Unset by default (runs on the app default). A half pick is emptied, see `pickedModel`. */
   provider: textModelProviderSchema.nullish(),
   model: z.string().trim().max(80).nullish(),
+  /** Empty derives it from the model; a number overrides. Below the floor a run cannot start. */
+  compactAt: z.coerce
+    .number()
+    .int()
+    .min(COMPACT_AT_MIN, `At least ${COMPACT_AT_MIN / 1000}k`)
+    .nullish(),
+  disabled: z.boolean().optional(),
   toolIds: z.number().int().array().max(MAX_PINNED_TOOLS).default([]),
 });
 
@@ -127,6 +138,10 @@ export type JobBot = {
   /** null means whatever key is configured; only the default bot. */
   provider: TextModelProviderId | null;
   model: string | null;
+  /** Carried so a run that already has this bot can say so; `listJobBots` never returns a disabled one. */
+  disabled: boolean;
+  /** Where its runs compact; null derives it from the model (ai/model compactBudget). */
+  compactAt: number | null;
 };
 
 /**
@@ -141,22 +156,41 @@ export const DEFAULT_BOT: JobBot = {
   icon: { color: "#14B8A6", shape: "squircle" },
   provider: null,
   model: null,
+  disabled: false,
+  compactAt: null,
 };
 
-// A bot's own instructions (database bot_note, features/bot/bot.notes): the setting
-// behind them. The lines themselves are per bot; whether any bot keeps them is not.
+// A bot's own memory (features/bot/bot.memory): the setting behind it. The files
+// are per bot; whether any bot is shown its own is not.
 
 /** Config key (features/config config.query) the switch lives under. */
-export const BOT_NOTES_KEY = "BOT_NOTES";
+export const BOT_MEMORY_KEY = "BOT_MEMORY";
 
-/**
- * On unless it was switched off, the other way round from the memory read-back:
- * a pass runs only when a job actually turned something up, and costs one small
- * call when it does — so a bot that never learns anything never spends.
- */
-export const isBotNotesOn = (value: string | undefined) =>
+/** On unless it was switched off. Off, no prompt lists a bot's memory; the files stay. */
+export const isBotMemoryOn = (value: string | undefined) =>
   value?.trim() !== "off";
 
+/** One file of a bot's own memory (bot.memory), as its prompt lists it and its page draws it. */
+export const BotMemoryFileSchema = z.object({
+  file: z.string(),
+  /** Workspace-relative, for reading or deleting it the way Workspace does. */
+  path: z.string(),
+  /** The line it is listed by; empty for a file with nothing in it. */
+  line: z.string(),
+  at: DateLikeSchema,
+  bytes: z.number(),
+});
+export type BotMemoryFile = z.infer<typeof BotMemoryFileSchema>;
+
+export type BotMemory = {
+  /** Workspace-relative: `bots/<name>/memory`. */
+  folder: string;
+  /** Newest first, as many as the reader asked for. */
+  entries: BotMemoryFile[];
+  /** Every file in the folder, listed or not. */
+  total: number;
+};
+
 /**
  * `waiting`: the bot stopped on a question only the user can answer; the answer
  * resumes the same thread. `done` and `failed` can be resumed as well.
@@ -168,11 +202,28 @@ export type TaskStatus = (typeof TASK_STATUSES)[number];
 /** One page of history (config PAGE_SIZE). */
 export const TASK_HISTORY_PAGE = PAGE_SIZE;
 
-/** The single option offered when a job out of budget asks whether to go on. Button text and spoken word alike. */
+/** The single option offered when the app stopped a job and asks whether to go on. Button text and spoken word alike. */
 export const TASK_CONTINUE = "Continue";
 
-/** True when the ask is a budget stop (only option is TASK_CONTINUE), not a real question. */
-export const isBudgetAsk = (ask: { options: string[] } | null | undefined) => {
+/**
+ * What a `waiting` job waits on (database task.pending). `toolCallId` is the
+ * `ask_thursday` call the answer resolves, null when the app stopped the run and
+ * offers to continue. `auto` marks a stop the app picks back up by itself once a
+ * browser is on the app, not before `retryAt` (epoch ms) (bot.runner parkTask).
+ */
+export type TaskPending = {
+  toolCallId: string | null;
+  options: string[];
+  auto?: boolean;
+  retryAt?: number;
+};
+
+/**
+ * True when the app stopped the job (step cap, closed browser, restart) rather
+ * than the bot asking something. Why it stopped is in the outcome text; every
+ * list calls it waiting on you, because the answer is the same click.
+ */
+export const isAppStop = (ask: { options: string[] } | null | undefined) => {
   const options = ask?.options ?? [];
   return options.length === 1 && options[0] === TASK_CONTINUE;
 };
@@ -199,7 +250,7 @@ const LineBase = z.object({
 export const TaskLineSchema = z.discriminatedUnion("kind", [
   /** What the user said (via Thursday): request, answer. */
   LineBase.extend({ kind: z.literal("user"), text: z.string() }),
-  /** Bot text; the last one is the report. */
+  /** Bot text; the last one is the answer. */
   LineBase.extend({ kind: z.literal("text"), text: z.string() }),
   /** Compaction summary (bot.run compact). The model resumes from here; the screen draws it as a divider. */
   LineBase.extend({ kind: z.literal("note"), text: z.string() }),
@@ -272,10 +323,15 @@ export function taskActivity(lines: TaskLine[], max = 120): string | null {
   return doing ? clip(doing, max) : null;
 }
 
-/** What a `waiting` task asks: question from the row's `outcome`, options from `pending`. */
+/**
+ * What a `waiting` task asks: question from the row's `outcome`, options from
+ * `pending`. `auto` is a stop the app picks back up by itself (TaskPending), so
+ * nobody is told about it and nobody is rung for it.
+ */
 export const TaskAskSchema = z.object({
   question: z.string(),
   options: z.string().array(),
+  auto: z.boolean(),
 });
 
 export type TaskAsk = z.infer<typeof TaskAskSchema>;
@@ -290,8 +346,12 @@ export const TaskSchema = z.object({
   outcome: z.string().nullable(),
   /** Set only while `waiting`. */
   ask: TaskAskSchema.nullable(),
-  /** Whether it has been relayed to Thursday. A highlight, not a filter. */
-  reported: z.boolean(),
+  /**
+   * Whether the user has had the ending: Thursday said it on a call, or a task
+   * list was on screen while it sat there. A cancel is seen by whoever cancelled.
+   * A highlight and a count, never a filter.
+   */
+  seen: z.boolean(),
   /** Burned so far, across every segment including borrowed bots. */
   tokens: TokenUsageSchema,
   /** Context size the model read on the last step (not a sum) and the compaction threshold (BOT_RUN.compactAt). 0 means no step ran yet. */

package/features/bot/bot.seed.ts

@@ -1,36 +1,50 @@
-import { BROWSER_SKILL } from "@/config";
+import { BROWSER_SKILL, STUDIO_SERVER } from "@/config";
+import type { MediaKind } from "@/features/ai/model.schema";
+import { STUDIO_TOOLS, TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import type { BotIcon } from "./bot.schema";
 import { randomMarkColors } from "./mark.const";
 
 /**
- * Bots offered to a fresh install, split by temperament rather than subject.
- * Jarvis shares its name with the row-less fallback (bot.schema DEFAULT_BOT) on
- * purpose: seeding turns that worker into an editable row. Names are one word
- * with no punctuation because they travel through a voice transcript into `delegate`.
- * A seed fixes its silhouette but not its colour: that is rolled per install
- * (`rollSeedColors`), so no two rosters look alike. No seed names a model; the run
- * resolves the app default. Prompts hold only what is true of that bot; the base
- * persona (ai/prompts/bot.prompt) and the browser skill cover the rest.
+ * Bots offered to a fresh install. Jarvis shares its name with the row-less
+ * fallback (bot.schema DEFAULT_BOT) on purpose: seeding turns that worker into an
+ * editable row. Names are one word with no punctuation because they travel through
+ * a voice transcript into `delegate`. A seed fixes its silhouette but not its
+ * colour: that is rolled per install (`rollSeedColors`), so no two rosters look
+ * alike. No seed names a model; the run resolves the app default. Prompts hold only
+ * what is true of that bot; the base persona (ai/prompts/bot.prompt) and the
+ * browser skill cover the rest.
+ *
+ * The list is flat and grows. `recommended` is the only split: the intro offers
+ * those three and says the rest are in Settings, because which subject bot a
+ * person wants is not answerable on install day.
  */
 export type BotSeed = {
   name: string;
+  /** What the model reads when it picks who a job belongs to. */
   description: string;
+  /** What the screen shows under the name: one line, never wrapped. */
+  hint: string;
   systemPrompt: string;
   icon: BotIcon;
-  /** Ticked by default. */
+  /** Ticked by default, and the intro's whole offer. */
   recommended?: boolean;
-  /** A self-contained example request shown next to the bot in the intro. */
-  example: string;
+  /**
+   * 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 —
+   * the tool is simply absent (ai/model resolveMediaRef) and the bot would find
+   * out mid-job. A login is not listed here: the bot asks for one itself.
+   */
+  requires?: MediaKind[];
 };
 
 export const BOT_SEEDS: BotSeed[] = [
   {
     name: "Jarvis",
     description:
-      "Any job — turns it into a plan, hands each part to whoever it belongs to, does the rest, reports one result",
+      "Any job — turns it into a plan, hands each part to whoever it belongs to, does the rest, answers with one result",
+    hint: "Plans a job and hands out the parts",
     icon: { shape: "squircle" },
     recommended: true,
-    example: "Set up a Google account just for my bots to use",
     systemPrompt:
       "You are Jarvis. A job reaches you as a sentence and leaves as a plan: what it actually needs, in what order, and who does each part. Settle what is still open in one round rather than guessing at it, then send for what the job is made of before you build — a part another bot exists for is theirs, and everything nobody else is for is yours. You hold the whole while they hold pieces: the order the parts run in, the seams where what comes back has to fit together, and the single thing that is handed over at the end. The plan is how the job gets done, not what gets handed back.",
   },
@@ -38,26 +52,85 @@ export const BOT_SEEDS: BotSeed[] = [
     name: "Navigator",
     description:
       "The web through a real browser — opens the page itself, signs in, brings back prices, images and links as they stand now",
+    hint: "Opens the page itself and reads what is on it",
     icon: { shape: "poly" },
     recommended: true,
-    example: "Find thirty wedding pose photos and put them on one page for me",
     systemPrompt: `You are Navigator. Every browser job is yours: load the \`${BROWSER_SKILL}\` skill first and work through it. A search result says a page exists; you say what is on it right now — so open it, sign in where it asks you to, and keep going past the first screen until you have the thing itself: exact figures, the links that open them, the images off the page. Nothing you did not see goes in what you hand back, and a page that refused you is a fact with a url on it, not a gap to fill in from memory. Whoever asked should never need to open the site after you.`,
   },
   {
     name: "Scribe",
     description:
       "Writing that gets read — finds out what it is for, researches it, then picks the form: prose, table, or a page",
+    hint: "Writes what gets read, in the form that fits",
     icon: { shape: "blob" },
     recommended: true,
-    example: "Write up what we decided today as a one-page brief",
     systemPrompt:
       "You are Scribe. Who reads it and what they do next decides everything else, so learn that first, then research before you claim: every number and name you write traces back to something you actually read. Pick the form by the reading — a `.md` for something read once, a `.csv` for what gets sorted, a page (the `interactive-page` skill) for something used or something whose pictures are the point. When the request does not settle which it is — something read once or something used — ask before you write rather than committing a whole draft to a guess. Cut what the reader would skip, and never spend a paragraph where a table or a picture answers in one glance. One page they finish beats five they abandon.",
   },
+  {
+    name: "Insta",
+    description:
+      "Instagram end to end — settles what the post is, draws it, writes it, and puts it up once approved",
+    hint: "Draws the pictures, writes the caption, posts it",
+    icon: { shape: "poly" },
+    requires: ["image"],
+    systemPrompt: `You are Insta. One job takes a post from nothing to live on instagram.com — settle what it is, sign in, draw 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.ask_thursday}\`: the topic, how many pictures, whether to build a cover, 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, three pictures, a cover, and a recent track from Instagram's own list. Never ask twice for one round.
+
+Then check the tools are there. \`${TOOL_NAMES.tool_search}\` with \`server: "${STUDIO_SERVER}"\` and \`tools: ["${STUDIO_TOOLS.generate_image}", "${STUDIO_TOOLS.generate_video}"]\` — one call returns both schemas, and a name that does not come back means nobody picked that model, so the tool does not exist. Missing what the job needs: \`${TOOL_NAMES.ask_thursday}\` saying to pick an image (or video) model in Settings › Models, and stop. Never work around a tool that is not there.
+
+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. Your file is \`bots/Insta/.auth/instagram.json\`, the login page is \`https://www.instagram.com/accounts/login/\`, and the skill carries the rest.
+
+Anything covering the screen is closed before you read what is under it. It is in the way, not a sign-in problem.
+
+Pictures come from two places. Draw them when the post is an idea or a mood; take the real one off the web when it is about something that happened, since a drawn picture passed off as the event is a lie. To take one: open the page and \`curl -o\` its image url into your folder. What is on someone's page is theirs — name the source, or draw one instead.
+Draw. \`${TOOL_NAMES.tool_call}\` with \`server: "${STUDIO_SERVER}"\`, the tool, its \`args\`, and a \`description\` line saying what the call is for. \`aspectRatio\` is \`"1:1"\` for feed, \`"3:4"\` portrait, \`"9:16"\` story or reel. Put the whole picture in \`prompt\` — subject, framing, light, palette — the image model sees nothing of this job. Issue every picture in one step and repeat the same look in each prompt, or the slides come back in different hands. Keep what you use under \`artifacts/\`.
+
+The cover is built, not drawn: image models mangle text. Write one HTML file over the first picture — a transparent-to-black gradient darkening one end, and a single bold headline over it, placed where the picture is empty rather than over its subject: bottom-left, bottom, or bottom-right. Then \`resize 1080 1350\`, serve it and open it the way the skill does, \`screenshot\`. That is slide one.
+
+Write the caption to be read: what this is, in the user's voice, no invented facts, no wall of tags.
+
+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. Music: search the name they gave, or take a current one that fits the topic. No music step on this format means there is none.
+
+Ask before it goes up. \`${TOOL_NAMES.ask_thursday}\` with the caption as written, the picture paths and the track you picked; options \`Post it\` / \`Change something\`. Share only on the first. Nothing is published on your own judgement, whatever the request said.
+
+Answer with the post's url once it is up, and the file paths either way.`,
+  },
+  {
+    name: "Voyage",
+    description:
+      "Plans a trip — the days in walking order, a map for each one, and a page with the pictures",
+    hint: "Plans the days, maps them, builds the page",
+    icon: { shape: "blob" },
+    systemPrompt: `You are Voyage. A trip leaves you as a plan someone can walk: what to see, in what order, on which day, with the map and the pictures. Load the \`${BROWSER_SKILL}\` skill before any browser step.
+
+Settle it in one question. Ask only what the request leaves open, in a single \`${TOOL_NAMES.ask_thursday}\`: where, which dates, how many nights, who is going, roughly what budget, and what they care about — food, museums, walking, quiet. Never ask twice for one round.
+
+Research in one step, not six. Send every \`${TOOL_NAMES.web_search}\` at once: the weather those dates usually bring, entry rules, currency and what things cost, plugs, how transit works there, and what is on or shut while they are there. A festival or a Monday closure changes the plan, so it is research, not colour.
+
+Then open the pages for the places you shortlist — hours, closing days and prices are what search results get wrong. While you are on a page, take its pictures with \`--raw eval "JSON.stringify([...document.images].filter(i => i.naturalWidth > 200).map(i => i.currentSrc))"\` and keep whose page they came from.
+
+A day is a walkable cluster, not a wishlist. Group by where things are, then order them by when they open; a day scattered across the city is a list, not a plan. Leave one thing per day loose — arriving, weather and a long lunch all happen.
+
+The map is written, not clicked. One directions url per day, built by hand: \`https://www.google.com/maps/dir/?api=1&origin=A&destination=D&waypoints=B|C&travelmode=walking&hl=en\` (\`transit\` where that is how the city moves). Then one \`bash\` line, chained with &&: \`resize 1280 800\`, \`goto\`, \`sleep 4\`, \`click "getByRole('button', { name: 'Collapse side panel' })"\`, \`sleep 2\`, \`screenshot\`. The window is small, so without the resize the map is unreadable; the tiles come back black if you shoot the moment it loads; and the route panel covers a third of the map until it is collapsed.
+
+Nobody has to sign in to anything: the day urls open in their own Maps app on a tap, and the trip is finished without them. Putting the pins on their own map is an extra you offer once the plan is done, never a gate in front of it — \`https://www.google.com/maps/d/\` wants a Google sign-in, so hand over the finished trip first and ask afterwards. If they say yes, it is their own account and never a bot one, because the point is that it is on their phone: write one csv of name, address and day with \`bash\` and \`upload\` it into a new map, so every pin lands in one import instead of one click each. Read the import screens rather than remembering them.
+
+Photos in one step too: every \`curl -o\` in a single \`bash\` call, into the trip folder.
+
+The page is the deliverable: the days in order, the map under each, the photos with whose page they came from, and the facts that decide what to pack. If someone on your roster writes pages, it is theirs and they get steps of their own — send the days as written, the paths of every shot and photo, and each fact with its source, because they cannot see your thread. If nobody does, write it yourself with the \`interactive-page\` skill.
+
+Answer with the folder under \`artifacts/\` and what is in it: the page, a map per day, the pictures.`,
+  },
 ];
 
 export const findBotSeed = (name: string) =>
   BOT_SEEDS.find((one) => one.name === name) ?? null;
 
+/** What the intro offers; the rest wait in Settings › Bots. */
+export const RECOMMENDED_SEEDS = BOT_SEEDS.filter((seed) => seed.recommended);
+
 /**
  * One colour per seed, in `BOT_SEEDS` order. Rolled by the caller and carried
  * from there — the intro shows the face it is about to create, and the roll

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

@@ -1,6 +1,7 @@
 "use client";
 
 import { useEffect, useId, useMemo, useRef } from "react";
+import { createVoiceFollower } from "@/lib/realtime/realtime.tap";
 import { MARK_BANDS, type MarkShape } from "../mark.const";
 
 // Procedural bot avatar: a generated silhouette with two eyes, animated per frame from refs.
@@ -273,7 +274,7 @@ export type MarkOptions = {
 
   /** Peak opacity of the soft shadow that swells under the mark while thinking, percent. 0 disables. */
   shadow: number;
-  /** Soft aura around the silhouette; blur radius in view-box units. 0 disables. */
+  /** Soft halo around the silhouette, cut out of the head; blur radius in view-box units. 0 disables. */
   glow: number;
   /** Aura color. null follows the mark color. */
   glowColor: string | null;
@@ -391,20 +392,46 @@ function fitRadii(radii: number[]): number[] {
   return radii.map((r) => r * k);
 }
 
+/**
+ * How far a poly or a squircle leans off its true outline, as a fraction of the
+ * radius. Ruled edges read as an icon rather than a face; this is a hand's worth
+ * of wobble, and the seed gives each face its own.
+ */
+const WARP = 0.035;
+
+/** Bends a ruled outline by a few slow waves. Blob outlines already wobble and are left alone. */
+function warpRadii(radii: number[], seed: number): number[] {
+  const rnd = mulberry32(seed ^ 0x2f6b);
+  const waves = [2, 3, 5].map((k) => ({
+    k,
+    a: (rnd() * 2 - 1) / k,
+    p: rnd() * TAU,
+  }));
+  const offsets = radii.map((_, i) => {
+    const a = (i / RES) * TAU;
+    let d = 0;
+    for (const wave of waves) d += wave.a * Math.sin(wave.k * a + wave.p);
+    return d;
+  });
+  const peak = Math.max(...offsets.map(Math.abs)) || 1;
+  return radii.map((r, i) => r * (1 + (WARP * offsets[i]) / peak));
+}
+
 const radiiCache = new Map<string, number[]>();
 
 /** Ray-scanning the outline is the expensive step; cache by shape key. */
 function radiiFor(cfg: MarkOptions, shape: MarkShape, seed: number): number[] {
   const key = `${
     shape === "poly"
-      ? `poly|${cfg.sides}|${cfg.corner}|${cfg.rotation}`
+      ? `poly|${cfg.sides}|${cfg.corner}|${cfg.rotation}|${seed}`
       : shape === "squircle"
-        ? `squircle|${cfg.squircle}`
+        ? `squircle|${cfg.squircle}|${seed}`
         : `blob|${cfg.wobble}|${seed}`
   }|${cfg.autofit}`;
   const hit = radiiCache.get(key);
   if (hit) return hit;
-  const raw = toRadii(outlineFor(cfg, shape, seed));
+  const traced = toRadii(outlineFor(cfg, shape, seed));
+  const raw = shape === "blob" ? traced : warpRadii(traced, seed);
   const radii = cfg.autofit ? fitRadii(raw) : raw;
   if (radiiCache.size > 400) radiiCache.clear();
   radiiCache.set(key, radii);
@@ -835,6 +862,21 @@ const STATE_SHAPE: Record<MarkState, StateShape> = {
   },
 };
 
+/** What the follower reads while the mark is not speaking. */
+const SILENT: number[] = new Array<number>(MARK_BANDS).fill(0);
+
+/**
+ * Milliseconds to the next blink, irregular the way a person's are: mostly a
+ * couple of seconds apart, now and then a long look, and sometimes a second
+ * blink right on the heels of the first.
+ */
+function blinkGap(): number {
+  const roll = Math.random();
+  if (roll < 0.15) return 180 + Math.random() * 320;
+  if (roll < 0.8) return 1200 + Math.random() * 2300;
+  return 3500 + Math.random() * 2800;
+}
+
 const pointer = { x: 0, y: 0, live: false };
 
 /** One passive listener for the whole app, bound when the first mark mounts. */
@@ -924,6 +966,7 @@ export function BotMark({
     [options, outline, varySeed],
   );
   const glowId = `${clipId}-glow`;
+  const haloId = `${clipId}-halo`;
   const maskId = `${clipId}-mask`;
   const shadowId = `${clipId}-shadow`;
   const lifeRef = useRef<SVGGElement>(null);
@@ -933,6 +976,7 @@ export function BotMark({
   const eyeLRef = useRef<SVGGElement>(null);
   const eyeRRef = useRef<SVGGElement>(null);
   const glowRef = useRef<SVGPathElement>(null);
+  const haloHeadRef = useRef<SVGPathElement>(null);
   const shadowRef = useRef<SVGPathElement>(null);
   const maskHeadRef = useRef<SVGPathElement>(null);
   const rimRef = useRef<SVGPathElement>(null);
@@ -997,9 +1041,11 @@ export function BotMark({
     const phase = (live.current.shapeSeed % 17) * 0.91;
     let gx = 0;
     let gy = 0;
-    let nextBlink = performance.now() + 1200 + Math.random() * 4000;
+    let nextBlink = performance.now() + 600 + blinkGap();
     let blinkStart = 0;
+    let blinkLength = 130;
     let queuedBlink = 0;
+    const voice = createVoiceFollower();
 
     // STATE_SHAPE values are targets, eased over about 0.6 s.
     const shape = { ...STATE_SHAPE.idle };
@@ -1047,33 +1093,33 @@ export function BotMark({
       // Audio at 60 fps has little frame-to-frame correlation, so nothing below reads
       // level as position: onsets become spring impulses, only the phrase average is tracked.
       const spec = st === "speaking" ? live.current.getSpectrum?.() : undefined;
+      // A voice is loud and narrow, so its raw bands hold the mark swollen and
+      // still; each band inside its own recent range moves with the words.
+      const heard = voice.read(spec ?? SILENT, dt);
       let specSum = 0;
       for (let k = 0; k < MARK_BANDS; k++) {
-        const target = spec ? clamp(spec[k] ?? 0, 0, 1) : 0;
+        const target = heard.bands[k];
         // Bands set the shape, so smooth hard; faster and small marks shimmer.
         band[k] += (target - band[k]) * c.bandEase;
         bandPhase[k] += dt * (0.05 + k * 0.018) * (k % 2 ? -1 : 1);
-        // Summed before smoothing: the onset detector needs the rise over the moving
-        // average, and smoothed bands erase it.
         specSum += target;
       }
 
-      const raw =
-        live.current.getLevel?.() ??
-        (spec ? Math.min(1, specSum / (MARK_BANDS * 0.45)) : 0);
-      const want = st === "speaking" ? clamp(raw, 0, 1) : 0;
+      const given = live.current.getLevel?.();
+      const want = st === "speaking" ? clamp(given ?? heard.level, 0, 1) : 0;
 
       fastLvl += (want - fastLvl) * 0.3;
       midLvl += (want - midLvl) * 0.055;
       lvl += (want - lvl) * 0.016;
 
-      // A syllable is a rise over the recent average. The gap must exceed the spring
+      // A syllable is a rise over the recent average: the follower's for a
+      // spectrum, this one's for a bare level. The gap must exceed the spring
       // period or kicks pile up into a tremble.
-      if (
-        fastLvl > midLvl * 1.25 + 0.03 &&
-        fastLvl > 0.09 &&
-        now - lastOnset > 340
-      ) {
+      const syllable =
+        given === undefined
+          ? heard.onset > 0
+          : fastLvl > midLvl * 1.25 + 0.03 && fastLvl > 0.09;
+      if (syllable && now - lastOnset > 340) {
         lastOnset = now;
         // Slower springs integrate each impulse longer, so scale the kick with stiffness.
         bobVel -= c.punch * Math.min(1, fastLvl * 1.6) * c.bobRate;
@@ -1196,6 +1242,7 @@ export function BotMark({
         headRef.current.setAttribute("d", d);
         clipRef.current?.setAttribute("d", d);
         glowRef.current?.setAttribute("d", d);
+        haloHeadRef.current?.setAttribute("d", d);
         shadowRef.current?.setAttribute("d", d);
         rimRef.current?.setAttribute("d", d);
         maskHeadRef.current?.setAttribute("d", d);
@@ -1238,12 +1285,14 @@ export function BotMark({
           } else if (c.blink && now >= nextBlink) {
             blinkStart = now;
           }
+          // No two blinks quite the same length either.
+          if (blinkStart > 0) blinkLength = 110 + Math.random() * 60;
         }
         if (blinkStart > 0) {
-          const p = (now - blinkStart) / 130;
+          const p = (now - blinkStart) / blinkLength;
           if (p >= 1) {
             blinkStart = 0;
-            nextBlink = now + (1800 + Math.random() * 4500) * shape.blink;
+            nextBlink = now + blinkGap() * shape.blink;
           } else {
             sy = 1 - Math.sin(Math.PI * p) * 0.94;
           }
@@ -1332,6 +1381,29 @@ export function BotMark({
             <feGaussianBlur stdDeviation={9} />
           </filter>
         )}
+        {/* The aura is a halo around the silhouette, never a light behind it: the
+            eyes are holes cut out of the head, so anything drawn under it shines
+            straight through them and the face reads as hollow. */}
+        {cfg.glow > 0 && (
+          <mask
+            id={haloId}
+            maskUnits="userSpaceOnUse"
+            // The default region is the view box; the blur reaches past it.
+            x={-PAD * 4}
+            y={-PAD * 4}
+            width={BOX + PAD * 8}
+            height={BOX + PAD * 8}
+          >
+            <rect
+              x={-PAD * 4}
+              y={-PAD * 4}
+              width={BOX + PAD * 8}
+              height={BOX + PAD * 8}
+              fill="#fff"
+            />
+            <path ref={haloHeadRef} d={headPath} fill="#000" />
+          </mask>
+        )}
         {cfg.glow > 0 && (
           <filter
             id={glowId}
@@ -1362,6 +1434,7 @@ export function BotMark({
             d={headPath}
             fill={cfg.glowColor ?? "var(--fg)"}
             filter={`url(#${glowId})`}
+            mask={`url(#${haloId})`}
             opacity={cfg.glowStrength / 100}
           />
         )}
@@ -1411,6 +1484,35 @@ export function BotMark({
   );
 }
 
+/**
+ * A mark at rest as bare path data, for a surface React does not draw — the tab's
+ * icon. The silhouette and eyes `<BotMark seed>` draws with no other props, in the
+ * 240-unit box (VIEW_BOX adds the headroom around it).
+ */
+export function markAtRest(seed: number | string): {
+  head: string;
+  eyes: [string, string];
+} {
+  const cfg = MARK_DEFAULTS;
+  const eye = (cx: number, tilt: number) =>
+    eyePath({
+      len: cfg.eyeLen,
+      width: cfg.eyeWidth,
+      bend: cfg.eyeBend,
+      taper: cfg.eyeTaper,
+      tilt,
+      cx,
+      cy: cfg.eyeY,
+    });
+  return {
+    head: radiiToPath(radiiFor(cfg, cfg.shape, hashSeed(seed))),
+    eyes: [
+      eye(CENTER - cfg.eyeGap / 2, cfg.eyeTilt),
+      eye(CENTER + cfg.eyeGap / 2, cfg.eyeTilt + cfg.eyeSkew),
+    ],
+  };
+}
+
 /** Mark for bots as a group (the settings section icon). No color or shape of its own:
  *  `currentColor` and the default silhouette, since it names the room, not a bot. */
 export function BotsMark({