@a-t-h-i/bot-lobby 0.2.0 → 0.4.0

package/src/pi/mascot-art.ts

@@ -1,4 +1,5 @@
 import type { TaskState } from "../schemas/task.ts";
+import { slotEmote } from "./kaomoji.ts";
 
 /**
  * Pure ASCII art data for the scene-based zen panel. No logic lives here: the
@@ -6,7 +7,7 @@ import type { TaskState } from "../schemas/task.ts";
  * that `zen.ts` and `zen-large.ts` compose. Every glyph is exactly one visible
  * column so the art stays narrow/ambiguous-width safe: the non-ASCII glyphs are
  * the lobby `⌂` in `BANNER_NARROW`, the panel's ◐/✓/✗ status family, and the
- * box-drawing, bar, eye and aura glyphs of the large scene (─ │ ┌ ┐ └ ┘ ╭ ╮ ╰ ╯ ╲ ╱ ╶ ├ ┤ ┬ ┴ █ ▓ ▒ ░ ▁ ▂ ▃ ◉ ◍ ◎ ◌ ○ ✦ ✧).
+ * box-drawing, bar, eye and aura glyphs of the large scene (─ │ ┌ ┐ └ ┘ ╭ ╮ ╰ ╯ ╲ ╱ ╶ ├ ┤ ┬ ┴ █ ▓ ▒ ░ ▁-▇ ◉ ◍ ◎ ◌ ○ ◓ ◒ ✦ ✧).
  */
 
 /**
@@ -105,36 +106,135 @@ export const ORACLE_COLORS: Record<OraclePose, { color: PanelColor; bold: boolea
   dormant: { color: "dim", bold: false },
 };
 
-/** One oracle frame: the crown orb, both window eyes and the seven-column mouth. */
+/** One oracle frame: the crown orb, both pupils and the seven-column mouth. */
 export interface OracleFrame {
   orb: string;
+  /**
+   * One-column pupil drawn inside its three-column eye window: `OPEN_EYE` takes
+   * the gaze's pupil, `CLOSED_EYE` fills the window as a lid, anything else is drawn as is.
+   */
   winL: string;
   winR: string;
   /** Exactly seven one-column glyphs; never moves the tower geometry. */
   mouth: string;
 }
 
+/** Oracle expression frame indexes, matching the shared schedule (see expressions.ts). */
+export const ORACLE_REST = 0;
+export const ORACLE_BLINK = 1;
+/** Both emote frames are the look-around; the second only dims the orb. */
+export const ORACLE_LOOK = 2;
+
+/** An open eye: its pupil comes from where the oracle is looking. */
+export const OPEN_EYE = "◉";
+/** A closed eye: the lid fills the whole window. */
+export const CLOSED_EYE = "─";
+/** A half-closed lid, mid-blink or half-asleep. */
+export const HALF_LID = "◒";
+/** Inner width of each eye window; the pupil moves across it. */
+export const EYE_WIDTH = 3;
+
+/** The oracle's straight, serious mouth: it never idles on a smile. */
+export const ORACLE_MOUTH = "  ───  ";
+
 /**
- * Indexed oracle expressions per pose: 0 rests, 1 blinks and 2-3 emote. While
- * orchestrating the oracle glances around (2) and speaks (3); dormant, it sleeps
- * with closed eyes, peeks (1) and snores (2). Every glyph is one column and every
- * mouth seven, so a frame swap never moves the tower geometry.
+ * Indexed oracle expressions per pose: rest, blink, then the two emote steps.
+ * Orchestrating, the oracle keeps a straight face and its emotes are a look
+ * around the room; dormant, it sleeps, peeks one eye open and snores (o, then O).
+ * While it talks the mouth lip-syncs instead.
  */
 export const ORACLE_FRAMES: Record<OraclePose, readonly OracleFrame[]> = {
   orchestrating: [
-    { orb: "◉", winL: "◉", winR: "◉", mouth: " ╰───╯ " },
-    { orb: "◉", winL: "─", winR: "─", mouth: " ╰───╯ " },
-    { orb: "◎", winL: "◍", winR: "◉", mouth: "  ───  " },
-    { orb: "◍", winL: "◉", winR: "◍", mouth: " ▁▂▃▂▁ " },
+    { orb: "◉", winL: OPEN_EYE, winR: OPEN_EYE, mouth: ORACLE_MOUTH },
+    { orb: "◉", winL: CLOSED_EYE, winR: CLOSED_EYE, mouth: ORACLE_MOUTH },
+    { orb: "◎", winL: OPEN_EYE, winR: OPEN_EYE, mouth: ORACLE_MOUTH },
+    { orb: "◍", winL: OPEN_EYE, winR: OPEN_EYE, mouth: ORACLE_MOUTH },
   ],
   dormant: [
-    { orb: "◌", winL: "─", winR: "─", mouth: "  ───  " },
-    { orb: "◌", winL: "◌", winR: "─", mouth: "  ───  " },
-    { orb: "○", winL: "─", winR: "─", mouth: "  ─o─  " },
-    { orb: "○", winL: "─", winR: "─", mouth: "  ───  " },
+    { orb: "◌", winL: CLOSED_EYE, winR: CLOSED_EYE, mouth: ORACLE_MOUTH },
+    { orb: "◌", winL: HALF_LID, winR: CLOSED_EYE, mouth: ORACLE_MOUTH },
+    { orb: "○", winL: CLOSED_EYE, winR: CLOSED_EYE, mouth: "  ─o─  " },
+    { orb: "○", winL: CLOSED_EYE, winR: CLOSED_EYE, mouth: "  ─O─  " },
   ],
 };
 
+/**
+ * Lid positions stepped through by a blink (one per `PHASE_MS`, the last held):
+ * half-lidded, shut, shut, half-lidded. Dormant, the "blink" is a sleepy peek:
+ * the left eye cracks open, looks, and drifts shut again.
+ */
+export const ORACLE_BLINKS: Record<OraclePose, readonly (readonly [string, string])[]> = {
+  orchestrating: [[HALF_LID, HALF_LID], [CLOSED_EYE, CLOSED_EYE], [CLOSED_EYE, CLOSED_EYE], [HALF_LID, HALF_LID]],
+  dormant: [[HALF_LID, CLOSED_EYE], [OPEN_EYE, CLOSED_EYE], [OPEN_EYE, CLOSED_EYE], [OPEN_EYE, CLOSED_EYE], [HALF_LID, CLOSED_EYE], [CLOSED_EYE, CLOSED_EYE]],
+};
+
+/**
+ * Where the pupils look. `x` moves the pupil across its three-column window
+ * (left, centre, right); `y` swaps its glyph, since the window is one row:
+ * `◓` looks up, `◉` straight ahead, `◒` down.
+ */
+export interface Gaze {
+  x: -1 | 0 | 1;
+  y: -1 | 0 | 1;
+}
+
+export const GAZE_AHEAD: Gaze = { x: 0, y: 0 };
+
+/** The pupil glyph for each vertical gaze. */
+export const ORACLE_PUPILS: Record<Gaze["y"], string> = { [-1]: "◓", 0: "◉", 1: "◒" };
+
+const look = (x: Gaze["x"], y: Gaze["y"]): Gaze => ({ x, y });
+
+/**
+ * The look-around emote, one step per `PHASE_MS` across both emote frames
+ * (~2 s): a slow scan left, up across the ceiling, right, down at the agents
+ * and back to you.
+ */
+export const ORACLE_LOOK_PATH: readonly Gaze[] = [
+  look(0, 0), look(-1, 0), look(-1, 0), look(-1, 0), look(-1, -1), look(-1, -1),
+  look(0, -1), look(1, -1), look(1, -1), look(1, 0), look(1, 0), look(1, 0),
+  look(1, 1), look(0, 1), look(0, 1), look(-1, 1), look(0, 0), look(0, 0),
+];
+
+/**
+ * Idle wandering when nothing holds the oracle's attention: it keeps returning
+ * to you between glances around the room. Starts looking ahead.
+ */
+export const ORACLE_WANDER: readonly Gaze[] = [
+  look(0, 0), look(-1, 0), look(0, 0), look(1, -1), look(1, 0), look(0, 0),
+  look(-1, 1), look(0, -1), look(0, 0), look(1, 1), look(-1, -1), look(0, 0),
+];
+
+/** Ticks the eyes hold one wandering spot (~2.5 s while work is live). */
+export const ORACLE_WANDER_TICKS = 10;
+
+/**
+ * Lip-sync while the oracle talks: a voice waveform that swells and falls, with
+ * a closed-mouth breath so it reads as phrases rather than a buzz.
+ */
+export const ORACLE_TALK: readonly string[] = [
+  " ▁▃▅▃▁ ",
+  "  ▂▆▂  ",
+  " ▂▄▇▄▂ ",
+  "  ▁▂▁  ",
+  " ▃▅▂▅▃ ",
+  " ▁▂▄▂▁ ",
+  "   ▁   ",
+  ORACLE_MOUTH,
+];
+
+/** The oracle's resting mood: steady by default, worried when the task is blocked. */
+export type OracleMood = "steady" | "worried";
+
+/** The resting mouth per mood: straight, or a tight frown when blocked. */
+export const ORACLE_MOOD_MOUTHS: Record<OracleMood, string> = {
+  steady: ORACLE_MOUTH,
+  worried: "  ╭─╮  ",
+};
+
+/** Ticks the eyes hold on one working agent before glancing to the next. */
+export const ORACLE_GAZE_TICKS = 8;
+
 /**
  * The seven-column aura above the crown, stepped by the spinner tick: sparkles
  * twinkle while the oracle orchestrates, and z's drift up while it sleeps.
@@ -159,33 +259,22 @@ const FACE_FRAMES: Record<SlotState, readonly string[]> = {
   failed: ["(>_<)", "(x_x)", "(T_T)", "(;_;)"],
 };
 
-/** Kaomoji emotes for the large scene: working nervous, done happy, failed scared. */
-const EMOTE_FACES: Record<SlotState, readonly string[]> = {
-  working: ["(٥↼_↼)", "(●´⌓`●)"],
-  idle: ["(-.-)", "(u.u)"],
-  done: ["(✿^‿^)", "(っ˘з(˘⌣˘ )"],
-  failed: ["ಥ_ಥ", "(〒﹏〒)"],
-};
-
-/** QA's success emotes are a flex and a victory dance rather than a smile. */
-const QA_DONE_FACES: readonly string[] = ["ᕙ( • ‿ • )ᕗ", "ᕕ( ᐛ )ᕗ"];
-
 /** Every compact face is five columns, so a centered column never shifts between frames. */
 export const FACE_WIDTH = 5;
 
 function buildSlotFrames(id: SlotId): Record<SlotState, readonly string[][]> {
   const frames = {} as Record<SlotState, readonly string[][]>;
   for (const state of SLOT_STATES) {
-    const emotes = id === "qa" && state === "done" ? QA_DONE_FACES : EMOTE_FACES[state];
-    frames[state] = [...FACE_FRAMES[state].slice(0, 2), ...emotes].map((face) => [face]);
+    frames[state] = [...FACE_FRAMES[state].slice(0, 2), ...slotEmote(id, { status: state }, 0)].map((face) => [face]);
   }
   return frames;
 }
 
 /**
  * Animated faces per slot: one row each. Rest (0) and blink (1) stay the five-column
- * ASCII eyes; the emote frames (2+) are status-aware kaomoji, wider than five columns,
- * so the scene centres each frame inside its fixed slot cell.
+ * ASCII eyes; the emote frames (2+) are the slot's default kaomoji for the status
+ * (open, blink, action). The live scene swaps in a situation-aware emote per
+ * expression (see kaomoji.ts); either way the scene centres each frame in its cell.
  */
 export const SLOT_FRAMES: Record<SlotId, Record<SlotState, readonly string[][]>> = {
   dev: buildSlotFrames("dev"),
@@ -223,8 +312,9 @@ export const COMPACT_FRAMES: Record<SlotId, Record<SlotState, readonly string[]>
 /**
  * The oracle tower: 13 columns wide, `rows` while height allows and `smallRows`
  * when it must shrink. `{aura}` twinkles over the radiant `{orb}` crown,
- * `{winL}`/`{winR}` are the two window eyes, `{mouth}` speaks and `{door}` is
- * the name over the door. The speech bubble hangs beside the crown.
+ * `{winL}`/`{winR}` are the three-column eye windows the pupils move in,
+ * `{mouth}` speaks and `{door}` is the name over the door. The speech bubble
+ * hangs beside the crown.
  */
 export interface TowerSpec {
   rows: readonly string[];
@@ -244,9 +334,9 @@ export const TOWER: TowerSpec = {
     "    ╱ │ ╲    ",
     "      │      ",
     "╭─────┴─────╮",
-    "│ ╭─╮   ╭─╮ │",
-    "│ │{winL}│   │{winR}│ │",
-    "│ ╰─╯   ╰─╯ │",
+    "│╭───╮ ╭───╮│",
+    "││{winL}│ │{winR}││",
+    "│╰───╯ ╰───╯│",
     "│  {mouth}  │",
     "├───┬───┬───┤",
     "│░▒▓│{door}│▓▒░│",
@@ -255,7 +345,7 @@ export const TOWER: TowerSpec = {
   smallRows: [
     "   ──({orb})──   ",
     "╭─────┴─────╮",
-    "│ │{winL}│   │{winR}│ │",
+    "││{winL}│ │{winR}││",
     "│░▒▓│{door}│▓▒░│",
     "└───┴───┴───┘",
   ],

package/src/pi/model-support.ts

@@ -0,0 +1,101 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  agentProfile,
+  isThinkingLevel,
+  THINKING_LEVELS,
+  type BotLobbyConfig,
+  type ProfileResolver,
+  type SubagentKind,
+  type ThinkingLevelName,
+} from "../schemas/configuration.ts";
+
+/** Find a model by `provider/id` (or bare id); undefined when the registry does not know it. */
+export type ModelLookup = (ref: string) => Model<Api> | undefined;
+
+export type { ProfileResolver };
+
+/** `provider/id` for a model, the form settings store. */
+export function modelRef(model: Pick<Model<Api>, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/** Thinking levels a model supports, in pi's order; every level when the model is unknown. */
+export function supportedThinking(model: Model<Api> | undefined): ThinkingLevelName[] {
+  if (!model) return [...THINKING_LEVELS];
+  return getSupportedThinkingLevels(model).filter((level): level is ThinkingLevelName => isThinkingLevel(level));
+}
+
+export interface ThinkingCheck {
+  /** The level to run at: the requested one, or pi's nearest supported level. */
+  level: string;
+  /** Set when the requested level had to change. */
+  warning?: string;
+}
+
+/** Clamp `level` to what `model` supports, explaining any change; unknown models pass through. */
+export function checkThinking(model: Model<Api> | undefined, level: string): ThinkingCheck {
+  if (!model || !isThinkingLevel(level)) return { level };
+  const clamped = clampThinkingLevel(model, level as ModelThinkingLevel);
+  if (clamped === level) return { level };
+  return { level: clamped, warning: `"${level}" thinking isn't supported by ${modelRef(model)} — using "${clamped}"` };
+}
+
+const LABELS: Record<SubagentKind | "master", string> = {
+  master: "Master",
+  designer: "Designer",
+  backend: "Backend",
+  qa: "QA",
+  scout: "Scout",
+  researcher: "Researcher",
+};
+
+export function kindLabel(kind: SubagentKind | "master"): string {
+  return LABELS[kind];
+}
+
+export interface ResolverOptions {
+  lookup: ModelLookup;
+  /** The session's model as `provider/id`; used only where settings name no model yet. */
+  sessionModel?: string;
+  /** Receives each distinct clamp warning once per process. */
+  warn?: (message: string) => void;
+}
+
+const warned = new Set<string>();
+
+/**
+ * Profiles straight from settings, with the thinking level clamped to what
+ * each model supports. A subagent whose model is still unset runs on the
+ * session's model (named explicitly on the command line) until settings pin one.
+ */
+export function createProfileResolver(config: BotLobbyConfig, options: ResolverOptions): ProfileResolver {
+  return (domain, role) => {
+    const profile = agentProfile(config, domain, role);
+    const model = profile.model ?? options.sessionModel;
+    const check = checkThinking(model ? options.lookup(model) : undefined, profile.thinking);
+    if (check.warning) {
+      const message = `bot-lobby: ${kindLabel(profile.kind)} — ${check.warning}. Change it in /bot-lobby settings.`;
+      if (!warned.has(message)) {
+        warned.add(message);
+        options.warn?.(message);
+      }
+    }
+    return { ...profile, model, thinking: check.level };
+  };
+}
+
+/** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */
+export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup, sessionModel?: string): string[] {
+  const entries: Array<[SubagentKind | "master", string, string]> = [
+    ["master", config.master.model, config.master.thinking],
+    ["designer", config.agents.designer.model, config.agents.designer.thinking],
+    ["backend", config.agents.backend.model, config.agents.backend.thinking],
+    ["qa", config.agents.qa.model, config.agents.qa.thinking],
+    ["researcher", config.researcher.model, config.researcher.thinking],
+  ];
+  return entries.flatMap(([kind, ref, level]) => {
+    const model = ref === "inherit" ? sessionModel : ref;
+    const check = checkThinking(model ? lookup(model) : undefined, level);
+    return check.warning ? [`${kindLabel(kind)}: ${check.warning}`] : [];
+  });
+}

package/src/pi/run-summary.ts

@@ -0,0 +1,170 @@
+/**
+ * One-line descriptions of subagent runs, shared by the transcript entries,
+ * `/bot-lobby runs`, the Master's reports and the zen feed row. Pure: every
+ * clock read arrives as `now`.
+ */
+import type { AgentRun } from "../schemas/findings.ts";
+import type { RunLogEntry } from "../schemas/task.ts";
+import { shortDuration } from "../text.ts";
+import { SLOT_LABELS, type SlotId } from "./mascot-art.ts";
+
+/** The zen column a run belongs to; a researcher reports under RESEARCH from any domain. */
+export function slotOf(run: Pick<AgentRun, "domain" | "role">): SlotId {
+  if (run.role === "researcher") return "research";
+  if (run.domain === "backend") return "dev";
+  return run.domain === "designer" ? "design" : "qa";
+}
+
+/** Upper-case agent name as the scene shows it (DEV, DESIGN, RESEARCH, QA). */
+export function agentName(run: Pick<AgentRun, "domain" | "role">): string {
+  return SLOT_LABELS[slotOf(run)];
+}
+
+/** Compact token count: 950, 41k, 1.2M. */
+export function tokens(count: number): string {
+  if (!Number.isFinite(count) || count < 1000) return String(Math.max(0, Math.round(count || 0)));
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  return `${(count / 1_000_000).toFixed(1)}M`;
+}
+
+function durationOf(run: Pick<AgentRun, "startedAt" | "finishedAt">, now: number): number {
+  const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
+  const elapsed = end - Date.parse(run.startedAt);
+  return Number.isFinite(elapsed) && elapsed > 0 ? elapsed : 0;
+}
+
+const STATUS_ICONS: Record<AgentRun["status"], string> = {
+  running: "◐",
+  success: "✓",
+  failed: "✗",
+  cancelled: "·",
+  timeout: "✗",
+};
+
+/** Why a run ended the way it did, in words, when that is not plain success. */
+export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "wrappedUp" | "attempts">): string[] {
+  const flags: string[] = [];
+  if (run.stalled) flags.push("stalled");
+  else if (run.status === "timeout") flags.push("hit its time limit");
+  else if (run.status === "failed") flags.push("failed");
+  else if (run.status === "cancelled") flags.push("cancelled");
+  if (run.wrappedUp) flags.push(run.status === "success" ? "wrapped up early — report may be partial" : "asked to wrap up");
+  if (run.attempts > 1) flags.push(`${run.attempts} attempts`);
+  return flags;
+}
+
+/**
+ * `✓ DEV worker · 3m 12s · 9 turns · 23 tools · 41k↑ 6k↓ · $0.12 · provider/model`,
+ * followed by any flags (stalled, time limit, wrapped up early, attempts).
+ */
+export function describeRun(run: AgentRun, now = Date.now()): string {
+  const parts = [`${STATUS_ICONS[run.status]} ${agentName(run)} ${run.role}`, shortDuration(durationOf(run, now))];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (run.tools) parts.push(`${run.tools} tool${run.tools === 1 ? "" : "s"}`);
+  if (run.usage && (run.usage.input || run.usage.output)) parts.push(`${tokens(run.usage.input)}↑ ${tokens(run.usage.output)}↓`);
+  if (run.usage?.cost) parts.push(`$${run.usage.cost.toFixed(2)}`);
+  if (run.model) parts.push(run.model);
+  parts.push(...runFlags(run));
+  const line = parts.join(" · ");
+  return run.status === "success" || !run.error ? line : `${line} — ${run.error.split("\n")[0]}`;
+}
+
+/** The persisted form of a finished run, for `task.runLog`. */
+export function runLogEntry(run: AgentRun): RunLogEntry {
+  return {
+    runId: run.runId,
+    domain: run.domain,
+    role: run.role,
+    status: run.status,
+    startedAt: run.startedAt,
+    ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+    ...(run.model ? { model: run.model } : {}),
+    ...(run.turns ?? run.usage?.turns ? { turns: run.turns ?? run.usage?.turns } : {}),
+    ...(run.tools ? { tools: run.tools } : {}),
+    ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
+    attempts: run.attempts,
+    ...(run.stalled ? { stalled: true } : {}),
+    ...(run.wrappedUp ? { wrappedUp: true } : {}),
+    ...(run.error ? { error: run.error.split("\n")[0]!.slice(0, 200) } : {}),
+  };
+}
+
+/** A persisted entry back as a run, so `describeRun` formats both the same way. */
+export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
+  return {
+    runId: entry.runId,
+    taskId,
+    domain: entry.domain,
+    role: entry.role,
+    status: entry.status,
+    output: "",
+    attempts: entry.attempts ?? 1,
+    startedAt: entry.startedAt,
+    ...(entry.finishedAt ? { finishedAt: entry.finishedAt } : {}),
+    ...(entry.model ? { model: entry.model } : {}),
+    ...(entry.turns ? { turns: entry.turns } : {}),
+    ...(entry.tools ? { tools: entry.tools } : {}),
+    ...(entry.input !== undefined ? { usage: { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0, turns: entry.turns ?? 0 } } : {}),
+    ...(entry.stalled ? { stalled: true } : {}),
+    ...(entry.wrappedUp ? { wrappedUp: true } : {}),
+    ...(entry.error ? { error: entry.error } : {}),
+  };
+}
+
+/** Silence after which a working agent reads as "quiet" in the scene. */
+export const QUIET_MS = 45_000;
+
+/** How long a running agent has produced nothing, or 0 when it is not running or has no clock yet. */
+export function quietFor(run: Pick<AgentRun, "status" | "lastEventAt" | "startedAt">, now: number): number {
+  if (run.status !== "running") return 0;
+  const last = run.lastEventAt ?? Date.parse(run.startedAt);
+  const quiet = now - last;
+  return Number.isFinite(quiet) && quiet > 0 ? quiet : 0;
+}
+
+export interface FeedLine {
+  text: string;
+  kind: "info" | "warning";
+}
+
+/** Ticks one working agent holds the feed before it rotates to the next (~3 s at the live clock). */
+export const FEED_ROTATE_TICKS = 12;
+
+/** What one working agent is doing right now, with a warning when something needs attention. */
+function liveFeed(run: AgentRun, now: number): FeedLine {
+  const name = agentName(run);
+  if (run.waitingFor) return { text: `⧗ ${name} waiting for ${run.waitingFor}${run.note ? ` · ${run.note}` : ""}`, kind: "warning" };
+  const quiet = quietFor(run, now);
+  if (quiet >= QUIET_MS) {
+    const doing = run.activity ? ` (last: ${run.activity}${run.detail ? ` ${run.detail}` : ""})` : "";
+    return { text: `! ${name} quiet for ${shortDuration(quiet)}${doing}`, kind: "warning" };
+  }
+  if (run.note && run.noteKind === "warning") return { text: `! ${name} ${run.note}`, kind: "warning" };
+  const parts = [`▸ ${name} ${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`turn ${turns}`);
+  if (run.tools) parts.push(`${run.tools} tools`);
+  if (run.usage && run.usage.input + run.usage.output > 0) parts.push(`${tokens(run.usage.input + run.usage.output)} tok`);
+  if (run.note) parts.push(run.note);
+  return { text: parts.join(" · "), kind: "info" };
+}
+
+/**
+ * The scene's feed row: a working agent that needs attention first, otherwise
+ * the working agents in rotation, otherwise the most recent finished run.
+ * Undefined before anything has run.
+ */
+export function feedLine(runs: readonly AgentRun[], now: number, tick: number): FeedLine | undefined {
+  const running = runs.filter((run) => run.status === "running");
+  if (running.length > 0) {
+    const lines = running.map((run) => liveFeed(run, now));
+    const warning = lines.find((line) => line.kind === "warning");
+    if (warning) return warning;
+    const index = Math.floor(Math.max(0, tick) / FEED_ROTATE_TICKS) % lines.length;
+    return lines[index];
+  }
+  const last = [...runs].filter((run) => run.finishedAt).sort((a, b) => Date.parse(a.finishedAt!) - Date.parse(b.finishedAt!)).at(-1);
+  if (!last) return undefined;
+  return { text: describeRun(last, now), kind: last.status === "success" && !last.wrappedUp ? "info" : "warning" };
+}