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

package/src/pi/tools.ts

@@ -4,11 +4,12 @@ import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
-import { inheritThinking } from "../schemas/configuration.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { isQuiet } from "./quiet.ts";
+import { createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
+import { agentName, describeRun } from "./run-summary.ts";
 import {
   ORCHESTRATE_ACTIONS,
   runWorkflowAction,
@@ -29,6 +30,15 @@ const OrchestrateSchema = Type.Object({
   plan: Type.Optional(Type.String({ description: "plan: the detailed internal plan" })),
   domain: Type.Optional(Type.String({ description: "implement/research: designer, backend, or qa" })),
   task: Type.Optional(Type.String({ description: "implement: the concrete step for that domain's worker" })),
+  assignments: Type.Optional(
+    Type.Array(
+      Type.Object({
+        domain: Type.String({ description: "designer, backend, or qa" }),
+        task: Type.String({ description: "the concrete step(s) for that domain's worker" }),
+      }),
+      { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
+    ),
+  ),
   approvalId: Type.Optional(Type.String({ description: "resolve_approval: the approval id from a worker result" })),
   decision: Type.Optional(
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
@@ -49,7 +59,7 @@ const DESCRIPTION = [
   "Actions: clarify (ask the user), scout (domain reconnaissance in parallel), research (summon the",
   "read-only researcher for cited internet evidence on a complex change, tool, plugin, doc set or",
   "dependency), propose (record the proposal and request approval), plan (record the internal",
-  "plan), implement (delegate one step to a domain worker), qa (final quality gate and the only",
+  "plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "review), knowledge (record approved knowledge or a decision),",
   "compact (replace a knowledge file with a rewritten version, archiving the old one),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
@@ -57,22 +67,39 @@ const DESCRIPTION = [
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
-/** Build the engine dependencies from the current Pi context. `thinking` is the live session level used by agents configured to inherit it. */
+/** Resolve a `provider/id` (or bare id) against the models this session knows. */
+export function modelLookup(ctx: ExtensionContext): ModelLookup {
+  return (ref) => {
+    const slash = ref.indexOf("/");
+    if (slash > 0) return ctx.modelRegistry.find(ref.slice(0, slash), ref.slice(slash + 1));
+    return ctx.modelRegistry.getAvailable().find((model) => model.id === ref);
+  };
+}
+
+/** Build the engine dependencies from the current Pi context; every agent's model and thinking come from settings. */
 export function workflowDeps(
   ctx: ExtensionContext,
   configDir: string,
   signal: AbortSignal | undefined,
   onUpdate: ((run: AgentRun) => void) | undefined,
   runProcess?: ProcessRunner,
-  thinking?: string,
 ): WorkflowDeps {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const hasUI = ctx.hasUI;
+  const config = loadConfig();
+  const warn = (message: string) => {
+    if (hasUI) ctx.ui.notify(message, "warning");
+  };
   return {
     root,
     configDir,
     cwd: ctx.cwd,
-    config: inheritThinking(loadConfig(), thinking),
+    config,
+    profile: createProfileResolver(config, {
+      lookup: modelLookup(ctx),
+      sessionModel: ctx.model ? modelRef(ctx.model) : undefined,
+      warn,
+    }),
     sessionId: ctx.sessionManager.getSessionId(),
     signal,
     onUpdate,
@@ -106,13 +133,28 @@ function runReporter(
 /** TUI-only transcript entries; these never enter the model's context. */
 function registerBotLobbyEntries(pi: ExtensionAPI): void {
   pi.registerEntryRenderer("bot-lobby", (entry, { expanded }, theme) => {
-    const data = entry.data as { kind?: string; taskId?: string; text?: string } | undefined;
+    const data = entry.data as { kind?: string; taskId?: string; text?: string; ok?: boolean } | undefined;
+    if (data?.kind === "run") {
+      // One compact line per finished subagent run.
+      return new Text(theme.fg(data.ok ? "dim" : "warning", data.text ?? ""), 0, 0);
+    }
     const header = `bot-lobby ${data?.taskId ?? ""} — ${data?.kind ?? "note"}`.trim();
     const body = data?.text ?? "";
     return new Text(`${theme.fg("accent", theme.bold(header))}\n${theme.fg("toolOutput", expanded ? body : truncate(body, 600))}`, 0, 0);
   });
 }
 
+/** A transcript line per finished run, plus a warning for anything that stalled or ran out of time. */
+function reportFinishedRuns(pi: ExtensionAPI, ctx: ExtensionContext, result: WorkflowResult): void {
+  for (const run of result.runs ?? []) {
+    const ok = run.status === "success" && !run.wrappedUp;
+    pi.appendEntry("bot-lobby", { kind: "run", taskId: result.taskId, text: describeRun(run), ok });
+    if (!ctx.hasUI) continue;
+    if (run.stalled) ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} stalled — ${run.error ?? "no output"}`, "warning");
+    else if (run.status === "timeout") ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} ${run.error ?? "hit its time limit"}`, "warning");
+  }
+}
+
 export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, runProcess?: ProcessRunner): void {
   registerBotLobbyEntries(pi);
   pi.registerTool({
@@ -128,11 +170,12 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
     renderShell: "self",
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const root = detectProjectRoot(ctx.cwd, configDir);
-      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess, pi.getThinkingLevel());
+      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess);
       const result = await runWorkflowAction(params as OrchestrateParams, deps);
       if (params.action === "propose" && params.proposal && result.ok) {
         pi.appendEntry("bot-lobby", { kind: "proposal", taskId: params.taskId, text: params.proposal });
       }
+      reportFinishedRuns(pi, ctx, result);
       applyStatus(ctx, root, configDir);
       return {
         content: [{ type: "text", text: result.message }],

package/src/pi/ui.ts

@@ -13,11 +13,16 @@ import {
   ORACLE_GAP,
   SLOT_GAP,
   talkFrame,
+  triggerEmote,
+  WORKING_BLINK_CHANCE,
+  WORKING_GAP,
   type ExpressionGap,
   type ExpressionState,
 } from "./expressions.ts";
 import { ORACLE_THINKING } from "./activity.ts";
-import { SLOT_IDS } from "./mascot-art.ts";
+import { SLOT_IDS, type SlotId } from "./mascot-art.ts";
+import { slotSituations } from "./zen-metrics.ts";
+import type { Situation } from "./kaomoji.ts";
 import { isQuiet, isSubagentProcess, toggleQuiet } from "./quiet.ts";
 import { panelLines, type ExpressionFrames, type OracleMotion } from "./zen.ts";
 
@@ -159,9 +164,31 @@ export function expressionTickDelay(states: readonly ExpressionState[], now: num
 type ExpressionKey = keyof ExpressionFrames;
 const EXPRESSION_KEYS: readonly ExpressionKey[] = [...SLOT_IDS, "oracle"];
 
-/** The oracle keeps a livelier schedule than the agent slots. */
-function gapFor(key: ExpressionKey): ExpressionGap {
-  return key === "oracle" ? ORACLE_GAP : SLOT_GAP;
+/** The oracle keeps its own schedule; working agents are livelier than idle ones. */
+function gapFor(key: ExpressionKey, situations?: Record<SlotId, Situation>): ExpressionGap {
+  if (key === "oracle") return ORACLE_GAP;
+  return situations?.[key].status === "working" ? WORKING_GAP : SLOT_GAP;
+}
+
+function blinkChanceFor(key: ExpressionKey, situations?: Record<SlotId, Situation>): number | undefined {
+  return key !== "oracle" && situations?.[key].status === "working" ? WORKING_BLINK_CHANCE : undefined;
+}
+
+/** A compact fingerprint of what a slot is going through; a change may earn a reaction. */
+export function situationKey(situation: Situation): string {
+  return [situation.status, situation.flag ?? "", situation.handover ? "handover" : "", situation.wrappedUp ? "wrapped" : ""].join("|");
+}
+
+/**
+ * Whether a slot's change of situation deserves an immediate emote: it started
+ * work, finished, failed, got flagged (waiting, quiet, retrying) or received a
+ * file. Going idle, or a flag clearing, passes quietly.
+ */
+export function isReaction(previous: string | undefined, next: Situation): boolean {
+  if (previous === undefined || previous === situationKey(next)) return false;
+  if (next.status === "idle") return false;
+  if (next.status !== "working") return true;
+  return !previous.startsWith("working|") || next.flag !== undefined || next.handover === true;
 }
 
 /** Animated zen scene + plan checklist shown above the editor while a task is active. */
@@ -172,6 +199,7 @@ class ZenWidget implements Component {
   private timer: ReturnType<typeof setInterval>;
   private disposed = false;
   private readonly expressions: Record<ExpressionKey, ExpressionState>;
+  private readonly situations: Partial<Record<SlotId, string>> = {};
   private readonly tui: TUI;
   private readonly theme: () => Theme;
   private readonly rng: () => number;
@@ -202,7 +230,15 @@ class ZenWidget implements Component {
   }
 
   private play(now: number): void {
-    for (const key of EXPRESSION_KEYS) this.expressions[key] = advanceExpression(this.expressions[key], now, this.rng, gapFor(key));
+    const situations = slotSituations(zenState.runs, now);
+    for (const key of EXPRESSION_KEYS) {
+      this.expressions[key] = advanceExpression(this.expressions[key], now, this.rng, gapFor(key, situations), blinkChanceFor(key, situations));
+    }
+    for (const id of SLOT_IDS) {
+      const situation = situations[id];
+      if (isReaction(this.situations[id], situation)) this.expressions[id] = triggerEmote(now, this.rng, gapFor(id, situations));
+      this.situations[id] = situationKey(situation);
+    }
   }
 
   /** One interval, retimed when work starts or stops or an expression plays. */
@@ -222,6 +258,10 @@ class ZenWidget implements Component {
     return Object.fromEntries(EXPRESSION_KEYS.map((key) => [key, this.expressions[key].frame]));
   }
 
+  private variants(): Partial<Record<SlotId, number>> {
+    return Object.fromEntries(SLOT_IDS.map((id) => [id, this.expressions[id].variant]));
+  }
+
   /**
    * The panel only changes with the tick, an expression frame, the widget state or
    * the elapsed second, so every other repaint (typing in the editor, streaming
@@ -233,11 +273,12 @@ class ZenWidget implements Component {
     const theme = this.theme();
     const expressions = this.frames();
     const quiet = isQuiet();
-    const frameKey = EXPRESSION_KEYS.map((key) => expressions[key] ?? 0).join(",");
+    const variants = this.variants();
+    const frameKey = [...EXPRESSION_KEYS.map((key) => expressions[key] ?? 0), ...SLOT_IDS.map((id) => variants[id] ?? 0)].join(",");
     const motion = this.motion(now);
     const key = `${width}|${rows}|${this.tick}|${frameKey}|${motion.phase}|${motion.talk}|${zenVersion}|${Math.floor(now / 1000)}|${quiet}`;
     if (this.cache && this.cache.key === key && this.cache.theme === theme) return this.cache.lines;
-    const opts = { width, rows, tick: this.tick, theme, expressions, oracleActivity, oracleMotion: motion };
+    const opts = { width, rows, tick: this.tick, theme, expressions, variants, oracleActivity, oracleMotion: motion };
     const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => truncateToWidth(line, width));
     this.cache = { key, theme, lines };
     return lines;

package/src/pi/zen-large.ts

@@ -41,6 +41,10 @@ import {
   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
@@ -73,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 {
@@ -115,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;
@@ -315,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);
@@ -565,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[] {
@@ -588,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),
   }));
 }
 
@@ -600,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, motion: OracleMotion): LargeSceneInput["oracle"] {
   const pose = oraclePose(task);
-  return { pose, frame: expressions.oracle ?? REST_FRAME, ...motion };
+  return { pose, frame: foldEmoteFrame(expressions.oracle ?? REST_FRAME), ...motion };
 }
 
 function sceneTasks(steps: readonly PlanStep[]): LargeTaskRow[] {
@@ -569,13 +587,14 @@ function sceneInput(
     tick,
     done: metrics.done,
     total: metrics.total,
-    slots: sceneSlots(metrics, opts.expressions ?? {}),
+    slots: sceneSlots(metrics, opts.expressions ?? {}, opts.variants ?? {}),
     tasks: sceneTasks(steps),
     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),
   };
 }
 
@@ -588,6 +607,8 @@ 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. */

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`,",