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

package/README.md

@@ -117,10 +117,21 @@ While the owning session has a task active, its transcript switches to a zen vie
 and the built-in spinner are hidden, and a widget above the editor animates the
 task. At 72 columns and wider it draws a large scene: a header box with the task
 title and state in its top border, a progress bar, and a metadata row with
-elapsed time, quiet-mode hint and task id; a spinner line above the oracle
-naming the master's live tool activity (`⠋ delegating`, `⠋ planning`) or
-`dormant` when the task is paused or finished; an oracle tower with its ORC
-door, animated orb, window eyes and seven-column mouth;
+elapsed time, quiet-mode hint and task id; an oracle tower with a twinkling
+aura (drifting z's while dormant), a radiant orb crown, two window eyes, a
+seven-column mouth and its ORC door. Its pupils look around: they move
+left, centre or right in each window and turn up `◓`, ahead `◉` or down `◒`.
+While agents work it looks down at them, taking turns between them; while it
+talks it looks at you; otherwise its eyes wander the room and keep returning
+to you. It keeps a straight, serious face (`───`), tightening into a frown
+only when the task is blocked, and its mouth lip-syncs as a voice waveform
+for ~2 s whenever it says something new. Every 6–12 s it blinks (lids
+stepping down and up) or scans the whole room; asleep, it peeks one eye open
+or snores. Beside the crown, the oracle's speech
+bubble, its tail on the orb, says what the master is doing (`⠋ delegating`,
+`⠋ thinking`, `· your turn` once its turn ends, `· dormant` when paused) above
+who is at work (`→ DEV · QA`), the current step (`step 3 of 7`) or the task
+phase (`awaiting your approval`);
 four animated slots — DEV, DESIGN, RESEARCH and QA — each with a status face, a
 caption and two status rows: while running, a braille spinner beside the agent's
 live one-word activity (for example `⠋ reading` or `⠋ editing`) with its elapsed
@@ -131,13 +142,22 @@ terminals keep the
 boxed banner, header and compact animated strip, whose working line names the
 newest running agent's activity and elapsed time. Each sprite rests on one calm
 face and, independently every 20–30 s, briefly blinks (~500 ms) or emotes
-(~2 s, stepping through its kaomoji frames); the oracle's mouth moves with its
+(~2 s, stepping through its kaomoji frames), all on one
 adaptive clock — 250 ms while work is live, 1 s when idle and ~120 ms while an
-expression plays — and their faces, colours and words follow each agent's status
+expression plays or the oracle talks — and their faces, colours and words follow each agent's status
 (working, idle, done, failed). The large scene's rest and blink frames stay the
 five-column ASCII eyes, while its emote frames are status-aware kaomoji: nervous
 while working, happy when done (QA flexes and dances), scared on failure. The
 header progress bar is plan-derived.
+
+The checklist follows the workers through the plan. Plan steps are read from
+`Step N` headings, a `Steps`/`Sequence`/`Order` section, or numbered lines, and
+only top-level items count (sub-points nested under a step never inflate it).
+Each worker instruction is matched to a step by an explicit label
+(`Step 3: ...`, `steps 2-4`) or, failing that, by shared paths, its opening
+phrase and word overlap, with near-ties going to the earliest open step so a
+file path reused across steps cannot pin progress to step 1. Every worker
+delegation is recorded on the task, so progress survives a reload.
 New tasks get a <=3-word title derived from the request (for example "create
 landing page") plus an id `TASK-<slug>` built from the full request, so the banner
 and header stay concise; older `TASK-<timestamp>` tasks keep loading untouched.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -23,7 +23,9 @@
     "access": "public"
   },
   "pi": {
-    "extensions": ["./src/index.ts"]
+    "extensions": [
+      "./src/index.ts"
+    ]
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/prompts/master.md

@@ -47,6 +47,11 @@ Assign work to the correct domain; never ask one domain to do another's. A
 cross-domain dependency is reported to you, and you decide whether another
 domain needs a task.
 
+Write the plan's steps as a numbered list under a `## Steps` heading, and open
+each `implement` task with its step number (`Step 3: ...`, or `Steps 3-4: ...`
+when one delegation covers several) so the user's checklist tracks progress
+exactly.
+
 ## Research
 
 Summon the researcher with `orchestrate action=research` (a `domain` and an

package/src/execution/pi-runner.ts

@@ -77,9 +77,12 @@ export interface StreamCollector {
  * them.
  */
 export function createStreamCollector(onEvent?: (event: PiStreamEvent) => void): StreamCollector {
-  let pending = "";
+  const partial: string[] = [];
   const kept: string[] = [];
   const keep = (line: string) => {
+    // Most lines are per-token `message_update` deltas or large tool results;
+    // skip the parse for any line that cannot be one of the two kept events.
+    if (!line.includes('"tool_execution_start"') && !line.includes('"message_end"')) return;
     let raw: unknown;
     try {
       raw = JSON.parse(line);
@@ -94,15 +97,21 @@ export function createStreamCollector(onEvent?: (event: PiStreamEvent) => void):
     if (event.type === "message_end" && event.message?.role === "assistant") kept.push(line);
   };
   return {
+    // Scan only the new chunk for line breaks; a long line split over many
+    // chunks is joined once, when its newline finally arrives.
     push(chunk) {
-      pending += chunk;
-      const lines = pending.split("\n");
-      pending = lines.pop() ?? "";
-      for (const line of lines) keep(line);
+      let start = 0;
+      let newline = chunk.indexOf("\n");
+      while (newline >= 0) {
+        const tail = chunk.slice(start, newline);
+        keep(partial.length > 0 ? partial.splice(0).join("") + tail : tail);
+        start = newline + 1;
+        newline = chunk.indexOf("\n", start);
+      }
+      if (start < chunk.length) partial.push(chunk.slice(start));
     },
     finish() {
-      if (pending) keep(pending);
-      pending = "";
+      if (partial.length > 0) keep(partial.splice(0).join(""));
       return kept.join("\n");
     },
   };
@@ -199,10 +208,13 @@ function wireOutput(
   onEvent?: (event: PiStreamEvent) => void,
 ): () => void {
   const collector = createStreamCollector(onEvent);
-  proc.stdout?.on("data", (chunk: Buffer) => collector.push(chunk.toString()));
-  proc.stderr?.on("data", (chunk: Buffer) => {
+  // Decode as UTF-8 streams so a multi-byte character split across chunks survives.
+  proc.stdout?.setEncoding("utf8");
+  proc.stderr?.setEncoding("utf8");
+  proc.stdout?.on("data", (chunk: string) => collector.push(chunk));
+  proc.stderr?.on("data", (chunk: string) => {
     // Keep stderr head-bounded: it only feeds exit-code error messages.
-    if (buffers.stderr.length < MAX_STREAM_CHARS) buffers.stderr += chunk.toString();
+    if (buffers.stderr.length < MAX_STREAM_CHARS) buffers.stderr += chunk;
   });
   return () => {
     buffers.stdout = collector.finish();

package/src/pi/activity.ts

@@ -22,6 +22,9 @@ const ACTIVITY_WORDS: Record<string, string> = {
 
 const FALLBACK_WORD = "working";
 
+/** What the oracle says between its own tool calls while a master turn runs. */
+export const ORACLE_THINKING = "thinking";
+
 export function activityWord(toolName: string): string {
   return ACTIVITY_WORDS[toolName.trim().toLowerCase()] ?? FALLBACK_WORD;
 }

package/src/pi/events.ts

@@ -8,7 +8,7 @@ import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity } from "./ui.ts";
-import { oracleActivityWord } from "./activity.ts";
+import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
 import { isSubagentProcess, visibleTools } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task } from "../schemas/task.ts";
@@ -43,9 +43,31 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
 
 
-  // The oracle spinner mirrors the master's own tool calls; subagents report into runs.
+  // The oracle's speech bubble mirrors the master's own turn: thinking between
+  // tool calls, the tool's word during one, and silent (your turn) once it ends.
+  // Subagents report into runs instead.
+  // Parallel tool calls: the newest still-running call keeps the word.
+  const inFlight = new Map<string, string>();
+  const showOracle = () => setOracleActivity([...inFlight.values()].at(-1) ?? ORACLE_THINKING);
+  pi.on("agent_start", () => {
+    if (isSubagentProcess()) return;
+    inFlight.clear();
+    showOracle();
+  });
   pi.on("tool_execution_start", (event) => {
-    if (!isSubagentProcess()) setOracleActivity(oracleActivityWord(event.toolName, event.args));
+    if (isSubagentProcess()) return;
+    inFlight.set(event.toolCallId, oracleActivityWord(event.toolName, event.args));
+    showOracle();
+  });
+  pi.on("tool_execution_end", (event) => {
+    if (isSubagentProcess()) return;
+    inFlight.delete(event.toolCallId);
+    showOracle();
+  });
+  pi.on("agent_end", () => {
+    if (isSubagentProcess()) return;
+    inFlight.clear();
+    setOracleActivity(undefined);
   });
   pi.on("session_shutdown", (_event, ctx) => {
     cancelAllRuns();

package/src/pi/expressions.ts

@@ -44,9 +44,20 @@ function unit(rng: () => number): number {
   return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
 }
 
-/** Random resting gap before the next expression, in `[BLINK_MIN_MS, BLINK_MAX_MS]`. */
-export function nextGap(rng: () => number): number {
-  return BLINK_MIN_MS + Math.round(unit(rng) * (BLINK_MAX_MS - BLINK_MIN_MS));
+/** Resting window between expressions, milliseconds. */
+export interface ExpressionGap {
+  min: number;
+  max: number;
+}
+
+/** Agent slots rest 20-30 s between expressions. */
+export const SLOT_GAP: ExpressionGap = { min: BLINK_MIN_MS, max: BLINK_MAX_MS };
+/** The oracle is the scene's centrepiece: it blinks and emotes every 6-12 s. */
+export const ORACLE_GAP: ExpressionGap = { min: 6_000, max: 12_000 };
+
+/** Random resting gap before the next expression, inside `gap` (the slot window by default). */
+export function nextGap(rng: () => number, gap: ExpressionGap = SLOT_GAP): number {
+  return gap.min + Math.round(unit(rng) * (gap.max - gap.min));
 }
 
 /** Whether the next expression blinks (~65%) or emotes (~35%). */
@@ -55,9 +66,9 @@ export function pickEvent(rng: () => number): "blink" | "emote" {
 }
 
 /** A freshly rested expression that fires for the first time after one random gap. */
-export function createExpression(now: number, rng: () => number): ExpressionState {
+export function createExpression(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
   const start = Number.isFinite(now) ? now : 0;
-  return { nextAt: start + nextGap(rng), until: start, startedAt: start, frame: REST_FRAME };
+  return { nextAt: start + nextGap(rng, gap), until: start, startedAt: start, frame: REST_FRAME };
 }
 
 /** True while `now` is inside a playing blink or emote. */
@@ -74,17 +85,43 @@ export function anyPlaying(states: readonly ExpressionState[], now: number): boo
  * Advance one sprite to `now`: start a blink or emote once the gap has elapsed,
  * drop back to the rest frame when it ends, and change nothing in between.
  */
-export function advanceExpression(state: ExpressionState, now: number, rng: () => number): ExpressionState {
+export function advanceExpression(
+  state: ExpressionState,
+  now: number,
+  rng: () => number,
+  gap: ExpressionGap = SLOT_GAP,
+): ExpressionState {
   if (!Number.isFinite(now)) return state;
   if (now < state.until) return state.frame >= EMOTE_FRAME ? steppedEmote(state, now) : state;
   if (now < state.nextAt) return state.frame === REST_FRAME ? state : { ...state, frame: REST_FRAME };
-  return play(now, rng);
+  return play(now, rng, gap);
 }
 
-function play(now: number, rng: () => number): ExpressionState {
+function play(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
   const blink = pickEvent(rng) === "blink";
   const until = now + (blink ? BLINK_MS : EMOTE_MS);
-  return { nextAt: until + nextGap(rng), until, startedAt: now, frame: blink ? BLINK_FRAME : EMOTE_FRAME };
+  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: blink ? BLINK_FRAME : EMOTE_FRAME };
+}
+
+/** One sub-step of a playing expression; the oracle's blink and glance step through these. */
+export const PHASE_MS = FAST_TICK_MS;
+
+/** Sub-steps elapsed in the playing expression, 0 while resting or on a bad clock. */
+export function expressionPhase(state: ExpressionState, now: number): number {
+  if (!isPlaying(state, now)) return 0;
+  const elapsed = now - state.startedAt;
+  return Number.isFinite(elapsed) && elapsed > 0 ? Math.floor(elapsed / PHASE_MS) : 0;
+}
+
+/** How long the oracle lip-syncs after it says something new, and one mouth shape's hold. */
+export const TALK_MS = 1800;
+export const TALK_STEP_MS = FAST_TICK_MS;
+
+/** Mouth-shape index while the oracle is still talking about what it said at `since`, else undefined. */
+export function talkFrame(since: number | undefined, now: number): number | undefined {
+  if (since === undefined || !Number.isFinite(since) || !Number.isFinite(now)) return undefined;
+  const elapsed = now - since;
+  return elapsed >= 0 && elapsed < TALK_MS ? Math.floor(elapsed / TALK_STEP_MS) : undefined;
 }
 
 /** Emote frame for `now`: one step per EMOTE_STEP_MS, clamped to the last frame. */

package/src/pi/mascot-art.ts

@@ -6,7 +6,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 and eye glyphs of the large scene (─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ═ █ ▓ ░ ◉ ◍ ◎ ◌ ○).
+ * box-drawing, bar, eye and aura glyphs of the large scene (─ │ ┌ ┐ └ ┘ ╭ ╮ ╰ ╯ ╲ ╱ ╶ ├ ┤ ┬ ┴ █ ▓ ▒ ░ ▁-▇ ◉ ◍ ◎ ◌ ○ ◓ ◒ ✦ ✧).
  */
 
 /**
@@ -105,35 +105,147 @@ export const ORACLE_COLORS: Record<OraclePose, { color: PanelColor; bold: boolea
   dormant: { color: "dim", bold: false },
 };
 
-/** One oracle frame: the tower 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 with a
- * pulsing orb, sweeping window eyes and a moving mouth. 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: "▂▂▂▂▂▂▂" },
-    { 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.
+ */
+export const ORACLE_AURA: Record<OraclePose, readonly string[]> = {
+  orchestrating: ["·  ✦  ·", " ✧ · ✧ ", "✦  ·  ✦", " · ✧ · "],
+  dormant: ["  z    ", "   z   ", "  z  Z ", "     Z "],
+};
+
+/** Ticks each aura frame holds: a calm twinkle rather than the spinner's pace. */
+export const ORACLE_AURA_TICKS = 2;
+
 /**
  * One frame per status and expression: index 0 is the calm rest face, 1 the
  * blink and 2-3 the emotes. Every status keeps the same frame count and one row
@@ -209,13 +321,15 @@ 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. `{orb}` is the pulsing bead, `{winL}`/`{winR}` the two
- * window eyes and `{door}` the name over the door.
+ * when it must shrink. `{aura}` twinkles over the radiant `{orb}` 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[];
   smallRows: readonly string[];
-  tokens: { orb: string; winL: string; winR: string; door: string; mouth: string };
+  tokens: { aura: string; orb: string; winL: string; winR: string; door: string; mouth: string };
 }
 
 export const TOWER_WIDTH = 13;
@@ -224,29 +338,32 @@ export const TOWER_DOOR = "ORC";
 
 export const TOWER: TowerSpec = {
   rows: [
-    "    \\ | /    ",
-    "     \\|/     ",
-    "     ─{orb}─     ",
+    "   {aura}   ",
+    "    ╲ │ ╱    ",
+    "   ──({orb})──   ",
+    "    ╱ │ ╲    ",
     "      │      ",
-    "┌─────┴─────┐",
-    "│▓▓▓▓▓▓▓▓▓▓▓│",
-    "├───────────┤",
-    "│ ┌─┐   ┌─┐ │",
-    "│ │{winL}│   │{winR}│ │",
-    "│ └─┘   └─┘ │",
-    "├───────────┤",
+    "╭─────┴─────╮",
+    "│╭───╮ ╭───╮│",
+    "││{winL}│ │{winR}││",
+    "│╰───╯ ╰───╯│",
     "│  {mouth}  │",
     "├───┬───┬───┤",
-    "│▓▓▓│{door}│▓▓▓│",
+    "│░▒▓│{door}│▓▒░│",
     "└───┴───┴───┘",
   ],
   smallRows: [
-    "     ─{orb}─     ",
-    "┌─────┴─────┐",
-    "│ ┌─┐   ┌─┐ │",
-    "│ │{winL}│   │{winR}│ │",
-    "│▓▓▓│{door}│▓▓▓│",
+    "   ──({orb})──   ",
+    "╭─────┴─────╮",
+    "││{winL}│ │{winR}││",
+    "│░▒▓│{door}│▓▒░│",
     "└───┴───┴───┘",
   ],
-  tokens: { orb: "{orb}", winL: "{winL}", winR: "{winR}", door: "{door}", mouth: "{mouth}" },
+  tokens: { aura: "{aura}", orb: "{orb}", winL: "{winL}", winR: "{winR}", door: "{door}", mouth: "{mouth}" },
 };
+
+/** The oracle's speech bubble: outer width including borders, and its text rows. */
+export const BUBBLE = { width: 24, lines: 2 } as const;
+
+/** What the oracle says while the master waits on the user between turns. */
+export const ORACLE_IDLE_WORD = "your turn";

package/src/pi/tools.ts

@@ -7,7 +7,7 @@ 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, summarizeRun } from "./ui.ts";
+import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { isQuiet } from "./quiet.ts";
 import {
   ORCHESTRATE_ACTIONS,
@@ -128,7 +128,7 @@ 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) => applyStatus(ctx, root, configDir, runs)), runProcess, pi.getThinkingLevel());
+      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess, pi.getThinkingLevel());
       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 });