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

package/src/pi/zen-large.ts

@@ -2,11 +2,26 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import {
   BAR,
   BUBBLE,
+  CLOSED_EYE,
+  EYE_WIDTH,
+  GAZE_AHEAD,
+  OPEN_EYE,
   ORACLE_AURA,
   ORACLE_AURA_TICKS,
+  ORACLE_BLINK,
+  ORACLE_BLINKS,
   ORACLE_COLORS,
-  ORACLE_IDLE_WORD,
   ORACLE_FRAMES,
+  ORACLE_GAZE_TICKS,
+  ORACLE_IDLE_WORD,
+  ORACLE_LOOK,
+  ORACLE_LOOK_PATH,
+  ORACLE_MOOD_MOUTHS,
+  ORACLE_PUPILS,
+  ORACLE_REST,
+  ORACLE_TALK,
+  ORACLE_WANDER,
+  ORACLE_WANDER_TICKS,
   ORACLE_WORDS,
   SLOT_FRAMES,
   SLOT_LABELS,
@@ -17,13 +32,19 @@ import {
   TOWER,
   TOWER_DOOR,
   TOWER_WIDTH,
+  type Gaze,
   type OracleFrame,
+  type OracleMood,
   type OraclePose,
   type PanelColor,
   type SlotId,
   type SlotState,
 } from "./mascot-art.ts";
 import type { PanelTheme } from "./zen.ts";
+import type { SlotFlag } from "./zen-metrics.ts";
+import { EMOTE_FRAME } from "./expressions.ts";
+import type { FeedLine } from "./run-summary.ts";
+import { shortDuration } from "../text.ts";
 
 /**
  * The large animated zen scene: a header box, the oracle tower with its speech
@@ -56,6 +77,10 @@ export interface LargeSlot {
   activity?: string;
   /** Run duration label rendered under the status row; "—" when idle. */
   elapsedLabel: string;
+  /** Waiting on a file, gone quiet or retrying; replaces the activity word while set. */
+  flag?: SlotFlag;
+  /** This expression's emote frames (open, blink, action, action); the status default when absent. */
+  emote?: readonly string[];
 }
 
 export interface LargeTaskRow {
@@ -63,6 +88,17 @@ export interface LargeTaskRow {
   status: "done" | "current" | "pending";
 }
 
+/** The oracle's pose plus the caller-clocked animation state (see expressions.ts). */
+export interface OracleInput {
+  pose: OraclePose;
+  /** Expression frame: rest, blink, glance or delight (snore while dormant). */
+  frame: number;
+  /** Sub-step inside the playing expression; steps the blink lids and the glance. */
+  phase?: number;
+  /** Lip-sync shape index while the oracle talks about something it just said. */
+  talk?: number;
+}
+
 /** Everything the large scene draws; assembled by the caller from task and runs. */
 export interface LargeSceneInput {
   taskId: string;
@@ -76,7 +112,7 @@ export interface LargeSceneInput {
   total: number;
   slots: readonly LargeSlot[];
   tasks: readonly LargeTaskRow[];
-  oracle: { pose: OraclePose; frame: number };
+  oracle: OracleInput;
   /** Master's live activity for the speech bubble; absent means it waits on the user. */
   oracleActivity?: string;
   /** Plain-words task phase ("writing the plan"); the bubble's fallback second line. */
@@ -87,6 +123,8 @@ export interface LargeSceneInput {
   alertKind?: "warning" | "error";
   /** Name over the tower door, `TOWER_DOOR` when omitted. */
   doorLabel?: string;
+  /** Live feed row under the agents: what the busiest agent is doing right now. */
+  feed?: FeedLine;
 }
 
 export const SLOT_CELL = 15;
@@ -287,14 +325,26 @@ function bodyLines(
   const sections = input.tasks.length > 0;
   const plan = pickPlan(avail, sections);
   const entries = plan.section ? clamp(avail - blockRows(plan) - 1, 0, MAX_TASK_ROWS) : 0;
+  const section = sectionLines(input, width, theme, entries);
+  // The feed row takes a spare row only: it never costs the tower, the agents or a checklist row.
+  const spare = avail - blockRows(plan) - section.length;
+  const feed = input.feed && plan.strip && spare >= 1 ? [feedRow(input.feed, width, theme)] : [];
   return [
     ...towerLines(input, width, theme, plan.tower),
     ...(plan.branch ? branchLines(input, width, theme) : []),
     ...(plan.strip ? slotLines(input, width, theme) : []),
-    ...sectionLines(input, width, theme, entries),
+    ...feed,
+    ...section,
   ];
 }
 
+/** One dim line under the agent strip; warnings take the warning colour. */
+function feedRow(feed: FeedLine, width: number, theme?: PanelTheme): string {
+  const left = sceneLeft(width) + 1;
+  const text = truncateToWidth(feed.text, Math.max(0, Math.min(SCENE_WIDTH - 2, width - left)), "…");
+  return " ".repeat(left) + (feed.kind === "warning" ? paint(text, "warning", theme) : paint(text, "dim", theme));
+}
+
 function blockRows(plan: LayoutPlan): number {
   const tower = TOWER_ROWS[plan.tower];
   return tower + (plan.branch ? BRANCH_ROWS : 0) + (plan.strip ? SLOT_ROWS : 0);
@@ -310,26 +360,98 @@ function oracleFrame(input: LargeSceneInput): OracleFrame {
   return frames[mod(input.oracle.frame, frames.length)]!;
 }
 
+function frameIndex(input: LargeSceneInput): number {
+  return mod(input.oracle.frame, ORACLE_FRAMES[input.oracle.pose].length);
+}
+
+function phaseOf(input: LargeSceneInput): number {
+  const phase = input.oracle.phase ?? 0;
+  return Number.isFinite(phase) && phase > 0 ? Math.floor(phase) : 0;
+}
+
+/** The oracle's resting mood: worried by a blocker, otherwise steady. */
+export function oracleMood(input: LargeSceneInput): OracleMood {
+  return input.alert && input.alertKind === "error" ? "worried" : "steady";
+}
+
+function isLooking(input: LargeSceneInput): boolean {
+  return frameIndex(input) >= ORACLE_LOOK;
+}
+
+/**
+ * Where the pupils look. The look-around emote scans the room; while talking the
+ * oracle looks at you; while agents work it looks down at them, moving on to
+ * the next one every `ORACLE_GAZE_TICKS`; otherwise its eyes wander the room.
+ */
+export function oracleGaze(input: LargeSceneInput): Gaze {
+  if (input.oracle.pose !== "orchestrating") return GAZE_AHEAD;
+  if (isLooking(input)) return ORACLE_LOOK_PATH[Math.min(phaseOf(input), ORACLE_LOOK_PATH.length - 1)]!;
+  if (input.oracle.talk !== undefined) return GAZE_AHEAD;
+  const working = input.slots.flatMap((slot, index) => (slot.status === "working" ? [index] : []));
+  if (working.length === 0) return ORACLE_WANDER[mod(Math.floor(input.tick / ORACLE_WANDER_TICKS), ORACLE_WANDER.length)]!;
+  const target = working[mod(Math.floor(input.tick / ORACLE_GAZE_TICKS), working.length)]!;
+  const centre = (input.slots.length - 1) / 2;
+  return { x: target < centre ? -1 : target > centre ? 1 : 0, y: 1 };
+}
+
+/** One eye window: a lid fills it, otherwise the pupil sits at the gaze column. */
+function eyeCell(pupil: string, gaze: Gaze): string {
+  if (pupil === CLOSED_EYE) return CLOSED_EYE.repeat(EYE_WIDTH);
+  const glyph = pupil === OPEN_EYE ? ORACLE_PUPILS[gaze.y] : pupil;
+  const at = Math.floor(EYE_WIDTH / 2) + gaze.x;
+  return Array.from({ length: EYE_WIDTH }, (_value, column) => (column === at ? glyph : " ")).join("");
+}
+
+/** Both pupils: blink lids step with the phase, the frame supplies the rest. */
+function oraclePupils(input: LargeSceneInput): readonly [string, string] {
+  if (frameIndex(input) === ORACLE_BLINK) {
+    const lids = ORACLE_BLINKS[input.oracle.pose];
+    return lids[Math.min(phaseOf(input), lids.length - 1)]!;
+  }
+  const frame = oracleFrame(input);
+  return [frame.winL, frame.winR];
+}
+
+/** The mouth: lip-sync while talking, the mood's straight line or frown otherwise; dormant it snores. */
+function oracleMouth(input: LargeSceneInput): string {
+  if (input.oracle.pose !== "orchestrating") return oracleFrame(input).mouth;
+  if (input.oracle.talk !== undefined) return ORACLE_TALK[mod(input.oracle.talk, ORACLE_TALK.length)]!;
+  return ORACLE_MOOD_MOUTHS[oracleMood(input)];
+}
+
+/** The whole face for this frame: orb, both eye windows (three columns each) and the mouth. */
+export function oracleFace(input: LargeSceneInput): { orb: string; left: string; right: string; mouth: string } {
+  const [left, right] = oraclePupils(input);
+  const gaze = oracleGaze(input);
+  return { orb: oracleFrame(input).orb, left: eyeCell(left, gaze), right: eyeCell(right, gaze), mouth: oracleMouth(input) };
+}
+
 function oracleAura(input: LargeSceneInput): string {
   const frames = ORACLE_AURA[input.oracle.pose];
   return frames[mod(Math.floor(input.tick / ORACLE_AURA_TICKS), frames.length)]!;
 }
 
-function towerRow(row: string, input: LargeSceneInput, theme?: PanelTheme): string {
-  const frame = oracleFrame(input);
+/** Painted token values for one frame; built once and shared by every tower row. */
+type TowerValues = ReadonlyMap<string, string>;
+
+function towerValues(input: LargeSceneInput, theme?: PanelTheme): TowerValues {
+  const face = oracleFace(input);
   const accent = ORACLE_COLORS[input.oracle.pose];
   const glow = (text: string) => paint(text, accent.color, theme, accent.bold);
-  const values = new Map<string, () => string>([
-    [TOWER.tokens.aura, () => paint(oracleAura(input), accent.color, theme)],
-    [TOWER.tokens.orb, () => glow(frame.orb)],
-    [TOWER.tokens.winL, () => glow(frame.winL)],
-    [TOWER.tokens.winR, () => glow(frame.winR)],
-    [TOWER.tokens.mouth, () => glow(frame.mouth)],
-    [TOWER.tokens.door, () => glow(input.doorLabel ?? TOWER_DOOR)],
+  return new Map([
+    [TOWER.tokens.aura, paint(oracleAura(input), accent.color, theme)],
+    [TOWER.tokens.orb, glow(face.orb)],
+    [TOWER.tokens.winL, glow(face.left)],
+    [TOWER.tokens.winR, glow(face.right)],
+    [TOWER.tokens.mouth, glow(face.mouth)],
+    [TOWER.tokens.door, glow(input.doorLabel ?? TOWER_DOOR)],
   ]);
+}
+
+function towerRow(row: string, values: TowerValues, theme?: PanelTheme): string {
   return row
     .split(TOWER_PATTERN)
-    .map((part) => values.get(part)?.() ?? paint(part, "muted", theme))
+    .map((part) => values.get(part) ?? paint(part, "muted", theme))
     .join("");
 }
 
@@ -384,23 +506,24 @@ function bubbleStart(rows: readonly string[]): number {
  * The tail from the oracle to the bubble: the tower row's trailing blanks plus
  * the one-column gap become `╶──` (`──(◉)── ╶──┤`); a full-width row gets a stub.
  */
-function tailRow(row: string, input: LargeSceneInput, theme?: PanelTheme): string {
+function tailRow(row: string, values: TowerValues, theme?: PanelTheme): string {
   const body = row.replace(/ +$/, "");
   const pad = row.length - body.length;
   const tail = pad >= 1 ? ` ╶${"─".repeat(pad - 1)}` : "╶";
-  return towerRow(body, input, theme) + paint(tail, "muted", theme);
+  return towerRow(body, values, theme) + paint(tail, "muted", theme);
 }
 
 function towerLines(input: LargeSceneInput, width: number, theme: PanelTheme | undefined, size: TowerSize): string[] {
   if (size === "none") return [];
   const rows = size === "small" ? TOWER.smallRows : TOWER.rows;
   const left = " ".repeat(sceneLeft(width) + Math.floor((SCENE_WIDTH - TOWER_WIDTH) / 2));
+  const values = towerValues(input, theme);
   const bubble = bubbleRows(input, theme);
   const start = bubbleStart(rows);
   return rows.map((row, index) => {
     const speech = bubble[index - start];
-    if (speech === undefined) return left + towerRow(row, input, theme);
-    const tower = index === start + 1 ? tailRow(row, input, theme) : `${towerRow(row, input, theme)} `;
+    if (speech === undefined) return left + towerRow(row, values, theme);
+    const tower = index === start + 1 ? tailRow(row, values, theme) : `${towerRow(row, values, theme)} `;
     return left + tower + speech;
   });
 }
@@ -464,7 +587,9 @@ function slotLines(input: LargeSceneInput, width: number, theme?: PanelTheme): s
 
 function slotFrame(slot: LargeSlot): readonly string[] {
   const frames = SLOT_FRAMES[slot.id][slot.status];
-  return frames[mod(slot.frame, frames.length)] ?? [];
+  const index = mod(slot.frame, frames.length);
+  const live = index >= EMOTE_FRAME ? slot.emote?.[index - EMOTE_FRAME] : undefined;
+  return live !== undefined ? [live] : frames[index] ?? [];
 }
 
 function faceCells(slots: readonly LargeSlot[], offsets: readonly number[], theme?: PanelTheme): Cell[] {
@@ -487,7 +612,7 @@ function wordCells(slots: readonly LargeSlot[], offsets: readonly number[], tick
   return slots.map((slot, index) => ({
     offset: offsets[index]!,
     text: centre(slotStatusText(slot, tick), SLOT_CELL),
-    paint: statusPaint(slot.status, theme),
+    paint: wordPaint(slot, theme),
   }));
 }
 
@@ -499,12 +624,25 @@ function elapsedCells(slots: readonly LargeSlot[], offsets: readonly number[], t
   }));
 }
 
-/** Working agents show the braille spinner with their live activity; every other state keeps its glyph and word. */
+/**
+ * Working agents show the braille spinner with their live activity, or a flag
+ * when they wait on a file, go quiet or retry; every other state keeps its
+ * glyph and word.
+ */
 function slotStatusText(slot: LargeSlot, tick: number): string {
   if (slot.status !== "working") return `${SLOT_STATE_GLYPHS[slot.status]} ${SLOT_STATE_WORDS[slot.status]}`;
+  if (slot.flag?.kind === "waiting") return "⧗ waiting";
+  if (slot.flag?.kind === "quiet") return `! quiet ${shortDuration(slot.flag.ms)}`;
+  if (slot.flag?.kind === "retry") return "↻ retrying";
   return `${SPIN_FRAMES[mod(tick, SPIN_FRAMES.length)]!} ${slot.activity ?? SLOT_STATE_WORDS.working}`;
 }
 
+/** Flagged working agents paint their status row in the warning colour. */
+function wordPaint(slot: LargeSlot, theme?: PanelTheme): ((text: string) => string) | undefined {
+  if (slot.status === "working" && slot.flag && theme) return (text) => paint(text, "warning", theme, true);
+  return statusPaint(slot.status, theme);
+}
+
 /** The elapsed row stays dim so the status row keeps the colour. */
 function dimPaint(theme?: PanelTheme): ((text: string) => string) | undefined {
   return theme ? (text) => theme.fg("dim", text) : undefined;

package/src/pi/zen-metrics.ts

@@ -9,6 +9,8 @@ import type { AgentRun } from "../schemas/findings.ts";
 import type { Task } from "../schemas/task.ts";
 import { SLOT_IDS, SLOT_LABELS, type SlotId, type SlotState } from "./mascot-art.ts";
 import { formatDuration, planChecklist } from "./zen.ts";
+import { QUIET_MS, quietFor, slotOf } from "./run-summary.ts";
+import type { Situation } from "./kaomoji.ts";
 
 export type { SlotId, SlotState };
 
@@ -21,6 +23,24 @@ export interface SlotView {
   activity?: string;
   /** "—" without a run, live since `startedAt` while running, fixed once terminal. */
   elapsedLabel: string;
+  /** Something about a working agent worth flagging in its status row. */
+  flag?: SlotFlag;
+  /** The run was asked to wrap up early. */
+  wrappedUp?: boolean;
+  /** A file was just handed to this agent by the file desk. */
+  handover?: boolean;
+}
+
+/** Status-row flags for a working agent, in priority order: waiting on a file, gone quiet, retrying. */
+export type SlotFlag = { kind: "waiting" } | { kind: "quiet"; ms: number } | { kind: "retry" };
+
+function slotFlag(run: AgentRun | undefined, now: number): SlotFlag | undefined {
+  if (!run || run.status !== "running") return undefined;
+  if (run.waitingFor) return { kind: "waiting" };
+  const quiet = quietFor(run, now);
+  if (quiet >= QUIET_MS) return { kind: "quiet", ms: quiet };
+  if (run.noteKind === "warning" && run.note && /retry/.test(run.note)) return { kind: "retry" };
+  return undefined;
 }
 
 export interface SceneMetrics {
@@ -36,12 +56,6 @@ export function runStatus(status: AgentRun["status"]): SlotState {
   return status === "success" ? "done" : "failed";
 }
 
-/** The column a run belongs to; a researcher reports under RESEARCH from any domain. */
-function slotOf(run: AgentRun): SlotId {
-  if (run.role === "researcher") return "research";
-  if (run.domain === "backend") return "dev";
-  return run.domain === "designer" ? "design" : "qa";
-}
 
 function latestRunFor(runs: AgentRun[], id: SlotId): AgentRun | undefined {
   let latest: AgentRun | undefined;
@@ -62,7 +76,17 @@ function runElapsedLabel(run: AgentRun | undefined, now: number): string {
 function slotView(id: SlotId, runs: AgentRun[], now: number): SlotView {
   const run = latestRunFor(runs, id);
   const status: SlotState = run ? runStatus(run.status) : "idle";
-  return { id, label: SLOT_LABELS[id], status, activity: run?.activity, elapsedLabel: runElapsedLabel(run, now) };
+  const flag = slotFlag(run, now);
+  return {
+    id,
+    label: SLOT_LABELS[id],
+    status,
+    activity: run?.activity,
+    elapsedLabel: runElapsedLabel(run, now),
+    ...(flag ? { flag } : {}),
+    ...(run?.wrappedUp ? { wrappedUp: true } : {}),
+    ...(run?.status === "running" && run.note?.startsWith("got ") ? { handover: true } : {}),
+  };
 }
 
 export function sceneMetrics(task: Task, runs: AgentRun[], now: number): SceneMetrics {
@@ -78,3 +102,19 @@ export function sceneMetrics(task: Task, runs: AgentRun[], now: number): SceneMe
     slots: SLOT_IDS.map((id) => slotView(id, runs, now)),
   };
 }
+
+/** Each slot's situation for its face: status, activity and flags (see kaomoji.ts). */
+export function slotSituation(slot: SlotView): Situation {
+  return {
+    status: slot.status,
+    ...(slot.activity ? { activity: slot.activity } : {}),
+    ...(slot.flag ? { flag: slot.flag.kind } : {}),
+    ...(slot.wrappedUp ? { wrappedUp: true } : {}),
+    ...(slot.handover ? { handover: true } : {}),
+  };
+}
+
+/** Per-slot situations straight from runs, for the widget's reaction triggers. */
+export function slotSituations(runs: AgentRun[], now: number): Record<SlotId, Situation> {
+  return Object.fromEntries(SLOT_IDS.map((id) => [id, slotSituation(slotView(id, runs, now))])) as Record<SlotId, Situation>;
+}

package/src/pi/zen.ts

@@ -26,7 +26,8 @@ import {
   type SlotId,
   type SlotState,
 } from "./mascot-art.ts";
-import { REST_FRAME } from "./expressions.ts";
+import { EMOTE_FRAME, REST_FRAME } from "./expressions.ts";
+import { slotEmote } from "./kaomoji.ts";
 import {
   LARGE_MIN_WIDTH,
   MAX_LARGE_LINES,
@@ -36,7 +37,9 @@ import {
   type LargeSlot,
   type LargeTaskRow,
 } from "./zen-large.ts";
-import { runStatus, sceneMetrics, type SceneMetrics, type SlotView } from "./zen-metrics.ts";
+import { runStatus, sceneMetrics, slotSituation, type SceneMetrics, type SlotView } from "./zen-metrics.ts";
+import { feedLine, QUIET_MS, quietFor } from "./run-summary.ts";
+import { shortDuration } from "../text.ts";
 
 /** Minimal slice of pi's Theme the panel needs; keeps zen.ts decoupled from the agent. */
 export interface PanelTheme {
@@ -412,8 +415,10 @@ export function workingLine(runs: AgentRun[], tick: number, theme?: PanelTheme,
   if (running.length > 0) {
     const run = running.at(-1)!;
     const spinner = theme ? theme.fg("accent", spin) : spin;
-    const activity = run.activity ?? "working";
-    return `  ${spinner} agents working (${running.length}) · ${run.domain}/${run.role} ${activity} ${formatDuration(runElapsed(run, now))}`;
+    const activity = `${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`;
+    const quiet = quietFor(run, now);
+    const warning = run.waitingFor ? ` · waiting for ${run.waitingFor}` : quiet >= QUIET_MS ? ` · quiet ${shortDuration(quiet)}` : "";
+    return `  ${spinner} agents working (${running.length}) · ${run.domain}/${run.role} ${activity} ${formatDuration(runElapsed(run, now))}${warning}`;
   }
   const last = runs.at(-1);
   if (!last) return "  ○ waiting for the first agent…";
@@ -437,6 +442,18 @@ function paintStatus(status: SlotState, text: string, theme?: PanelTheme): strin
 /** Caller-chosen expression frame per slot and the oracle; absent reads as rest. */
 export type ExpressionFrames = Partial<Record<SlotId | "oracle", number>>;
 
+/** Per-expression variant per slot; picks which kaomoji an emote shows. */
+export type ExpressionVariants = Partial<Record<SlotId, number>>;
+
+/**
+ * The oracle and the compact strip keep their original two emote steps: the
+ * four emote frames (open, blink, action, action) fold onto them pairwise.
+ */
+export function foldEmoteFrame(frame: number): number {
+  if (!Number.isFinite(frame) || frame < EMOTE_FRAME) return frame;
+  return EMOTE_FRAME + Math.min(1, Math.floor((frame - EMOTE_FRAME) / 2));
+}
+
 /** Frame `index` wrapped into the art's frame list; a non-finite index rests. */
 function frameAt(frames: readonly string[], index: number): string {
   if (frames.length === 0) return "";
@@ -455,7 +472,7 @@ const COMPACT_INNER = SLOT_IDS.length * COMPACT_WIDTH + (SLOT_IDS.length - 1) *
 const COMPACT_STATUS_GAP = " ".repeat(COMPACT_WIDTH + COMPACT_GAP - 1);
 
 function compactFrame(slot: SlotView, expressions: ExpressionFrames): string {
-  return frameAt(COMPACT_FRAMES[slot.id][slot.status], expressions[slot.id] ?? REST_FRAME);
+  return frameAt(COMPACT_FRAMES[slot.id][slot.status], foldEmoteFrame(expressions[slot.id] ?? REST_FRAME));
 }
 
 function compactRow(content: string, color: PanelColor, theme?: PanelTheme): string {
@@ -530,16 +547,17 @@ function oraclePose(task: Task): OraclePose {
   return task.paused || TERMINAL_STATES.includes(task.state) ? "dormant" : "orchestrating";
 }
 
-function sceneSlots(metrics: SceneMetrics, expressions: ExpressionFrames): LargeSlot[] {
+function sceneSlots(metrics: SceneMetrics, expressions: ExpressionFrames, variants: ExpressionVariants): LargeSlot[] {
   return metrics.slots.map((slot) => ({
     ...slot,
     frame: expressions[slot.id] ?? REST_FRAME,
+    emote: slotEmote(slot.id, slotSituation(slot), variants[slot.id] ?? 0),
   }));
 }
 
-function oracleSlot(task: Task, expressions: ExpressionFrames): LargeSceneInput["oracle"] {
+function oracleSlot(task: Task, expressions: ExpressionFrames, motion: OracleMotion): LargeSceneInput["oracle"] {
   const pose = oraclePose(task);
-  return { pose, frame: expressions.oracle ?? REST_FRAME };
+  return { pose, frame: foldEmoteFrame(expressions.oracle ?? REST_FRAME), ...motion };
 }
 
 function sceneTasks(steps: readonly PlanStep[]): LargeTaskRow[] {
@@ -556,8 +574,7 @@ function sceneInput(
   quiet: boolean,
   tick: number,
   steps: PlanStep[],
-  expressions: ExpressionFrames,
-  oracleActivity: string | undefined,
+  opts: PanelOptions,
 ): LargeSceneInput {
   const metrics = sceneMetrics(task, runs, now);
   const alert = taskAlert(task);
@@ -570,13 +587,14 @@ function sceneInput(
     tick,
     done: metrics.done,
     total: metrics.total,
-    slots: sceneSlots(metrics, expressions),
+    slots: sceneSlots(metrics, opts.expressions ?? {}, opts.variants ?? {}),
     tasks: sceneTasks(steps),
-    oracle: oracleSlot(task, expressions),
-    oracleActivity,
+    oracle: oracleSlot(task, opts.expressions ?? {}, opts.oracleMotion ?? {}),
+    oracleActivity: opts.oracleActivity,
     caption: task.paused ? "task paused" : SCENE_PROPS[task.state],
     alert: alert?.text,
     alertKind: alert?.kind,
+    feed: feedLine(runs, now, tick),
   };
 }
 
@@ -589,8 +607,18 @@ export interface PanelOptions {
   theme?: PanelTheme;
   /** Caller-scheduled expression frame per slot and the oracle; absent means rest. */
   expressions?: ExpressionFrames;
+  /** Caller-drawn variant per slot expression; picks the emote's face. */
+  variants?: ExpressionVariants;
   /** Live master activity word for the oracle's speech bubble; absent means it waits on the user. */
   oracleActivity?: string;
+  /** Caller-clocked oracle animation: the expression's sub-step and the lip-sync shape. */
+  oracleMotion?: OracleMotion;
+}
+
+/** The oracle's clocked animation state beyond its expression frame (see expressions.ts). */
+export interface OracleMotion {
+  phase?: number;
+  talk?: number;
 }
 
 /**
@@ -613,7 +641,7 @@ export function panelLines(
   const steps = planChecklist(task.plan ?? "", runs);
   const budget = largeLineBudget(opts.rows ?? DEFAULT_ROWS);
   if (width >= LARGE_MIN_WIDTH && budget >= MIN_LARGE_LINES) {
-    const scene = largeLines(sceneInput(task, runs, now, quiet, tick, steps, opts.expressions ?? {}, opts.oracleActivity), width, budget, opts.theme);
+    const scene = largeLines(sceneInput(task, runs, now, quiet, tick, steps, opts), width, budget, opts.theme);
     return scene.map((line) => truncateToWidth(line, width));
   }
   return compactPanel(task, runs, now, quiet, tick, steps, opts, width);

package/src/roles/reviewer.ts

@@ -13,7 +13,8 @@ export const reviewerSpec: RoleSpec = {
     "Begin with `## Verdict` followed by exactly one of `PASS`, `CHANGES_REQUIRED`, or `BLOCKED`.",
     "Then `## Findings`, `## Verification`, `## Required Changes`, `## Optional Improvements`.",
     "Findings entries are `- [severity] text — \\`path:line\\``.",
-    "Verification entries are `- command — result`.",
+    "Verification entries are `- command — result` for checks you actually executed; a PASS without them is",
+    "treated as CHANGES_REQUIRED.",
     "You must not modify implementation files. Report required changes instead.",
     "An optional `## Pushback` (`**Request:**`, `**Reason:**`, optional `**Alternative:**`) flags a change request you",
     "believe is wrong, with your reason; keep it separate from your findings.",
@@ -35,18 +36,36 @@ function parseFinding(text: string): ReviewFinding {
   return { severity, text: (match?.[2] ?? text).trim() };
 }
 
+/** The QA gate never passes by default: a PASS must cite at least one executed check. */
+export const UNVERIFIED_PASS = "unverified pass: PASS without executed checks under ## Verification, downgraded to CHANGES_REQUIRED";
+
+/** A verification bullet names a command or check and its result (`- cmd — result`). */
+function executedChecks(verification: string): string[] {
+  return bullets(verification).filter((entry) => /\S\s*(?:—|–|-{1,2}|:|=>|→)\s*\S/.test(entry));
+}
+
 /** Parse a reviewer's markdown into a structured verdict (never throws). */
 export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
   const sections = parseSections(raw);
+  const verification = findSection(sections, "verification") ?? "";
+  const requiredChanges = bullets(findSection(sections, "required changes"));
+  let verdict = parseVerdict(findSection(sections, "verdict"));
+  let downgraded: string | undefined;
+  if (verdict === "pass" && executedChecks(verification).length === 0) {
+    verdict = "changes_required";
+    downgraded = UNVERIFIED_PASS;
+    requiredChanges.push("Re-run the QA gate and record the checks actually executed, each as `- command — result`.");
+  }
   return {
     domain,
     role: "reviewer",
-    verdict: parseVerdict(findSection(sections, "verdict")),
+    verdict,
     findings: bullets(findSection(sections, "findings")).map(parseFinding),
-    verification: findSection(sections, "verification") ?? "",
-    requiredChanges: bullets(findSection(sections, "required changes")),
+    verification,
+    requiredChanges,
     optionalImprovements: bullets(findSection(sections, "optional improvements")),
     pushback: parsePushback(sections),
+    ...(downgraded ? { downgraded } : {}),
     raw,
   };
 }
@@ -55,6 +74,7 @@ export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
 export function validateReviewResult(result: ReviewResult): string[] {
   const issues: string[] = [];
   if (!/##\s*verdict/i.test(result.raw)) issues.push("missing Verdict section");
+  if (result.downgraded) issues.push(result.downgraded);
   if (result.verdict !== "pass" && result.findings.length === 0 && result.requiredChanges.length === 0) {
     issues.push("non-pass verdict without findings or required changes");
   }

package/src/roles/worker.ts

@@ -3,10 +3,16 @@ import type { Blocker } from "../schemas/task.ts";
 import type { FileChange, KnowledgeProposal, WorkerResult } from "../schemas/findings.ts";
 import { bullets, fieldValue, findSection, parseFileBullet, parsePushback, parseSections } from "./markdown.ts";
 
-/** Worker has no tool allowlist: it needs the full set to implement. */
+/**
+ * Workers implement, so they get the full built-in set, including the fast
+ * search tools; the file desk adds its own tools when workers run in parallel.
+ */
+export const WORKER_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+
 export const workerSpec: RoleSpec = {
   role: "worker",
   promptFile: "worker.md",
+  tools: WORKER_TOOLS,
   contract: [
     "### Output contract",
     "Respond with exactly these sections and nothing else: `## Completed`, `## Files Changed`,",