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

package/README.md

@@ -117,10 +117,13 @@ 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, window eyes, a
+seven-column mouth and its ORC door; 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
@@ -138,6 +141,15 @@ expression plays — and their faces, colours and words follow each agent's stat
 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.2.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/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,7 +105,7 @@ 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 window eyes and the seven-column mouth. */
 export interface OracleFrame {
   orb: string;
   winL: string;
@@ -115,25 +115,38 @@ export interface OracleFrame {
 }
 
 /**
- * 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: 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.
  */
 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: "◉", winR: "◉", mouth: " ╰───╯ " },
+    { orb: "◉", winL: "─", winR: "─", mouth: " ╰───╯ " },
+    { orb: "◎", winL: "◍", winR: "◉", mouth: "  ───  " },
+    { orb: "◍", winL: "◉", winR: "◍", mouth: " ▁▂▃▂▁ " },
   ],
   dormant: [
-    { orb: "◌", winL: "◌", winR: "◌", mouth: "═══════" },
-    { orb: "◌", winL: "─", winR: "─", mouth: "═══════" },
-    { orb: "○", winL: "◌", winR: "◌", mouth: "▂▂▂▂▂▂▂" },
-    { orb: "○", winL: "─", winR: "─", mouth: "▁▁▁▁▁▁▁" },
+    { orb: "◌", winL: "─", winR: "─", mouth: "  ───  " },
+    { orb: "◌", winL: "◌", winR: "─", mouth: "  ───  " },
+    { orb: "○", winL: "─", winR: "─", mouth: "  ─o─  " },
+    { orb: "○", winL: "─", winR: "─", mouth: "  ───  " },
   ],
 };
 
+/**
+ * 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 +222,14 @@ 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 two window eyes, `{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 +238,32 @@ export const TOWER_DOOR = "ORC";
 
 export const TOWER: TowerSpec = {
   rows: [
-    "    \\ | /    ",
-    "     \\|/     ",
-    "     ─{orb}─     ",
+    "   {aura}   ",
+    "    ╲ │ ╱    ",
+    "   ──({orb})──   ",
+    "    ╱ │ ╲    ",
     "      │      ",
-    "┌─────┴─────┐",
-    "│▓▓▓▓▓▓▓▓▓▓▓│",
-    "├───────────┤",
-    "│ ┌─┐   ┌─┐ │",
+    "╭─────┴─────╮",
+    "│ ╭─╮   ╭─╮ │",
     "│ │{winL}│   │{winR}│ │",
-    "│ └─┘   └─┘ │",
-    "├───────────┤",
+    "│ ╰─╯   ╰─╯ │",
     "│  {mouth}  │",
     "├───┬───┬───┤",
-    "│▓▓▓│{door}│▓▓▓│",
+    "│░▒▓│{door}│▓▒░│",
     "└───┴───┴───┘",
   ],
   smallRows: [
-    "     ─{orb}─     ",
-    "┌─────┴─────┐",
-    "│ ┌─┐   ┌─┐ │",
+    "   ──({orb})──   ",
+    "╭─────┴─────╮",
     "│ │{winL}│   │{winR}│ │",
-    "│▓▓▓│{door}│▓▓▓│",
+    "│░▒▓│{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 });

package/src/pi/ui.ts

@@ -26,18 +26,36 @@ export function statusText(task: Task | undefined, minimized = false): string {
 }
 
 let zenOn = false;
-let zenState: { task: Task | undefined; runs: AgentRun[] } = { task: undefined, runs: [] };
 
-/** Latest master tool activity; the oracle spinner line shows it. */
+/**
+ * Widget state. `live` holds the runs reported in this session; `runs` is what the
+ * panel draws: the task's persisted worker records overlaid by the live copies,
+ * so the checklist replays after a reload. `version` bumps on every change and
+ * keys the widget's render cache.
+ */
+let zenState: { task: Task | undefined; live: AgentRun[]; runs: AgentRun[] } = { task: undefined, live: [], runs: [] };
+let zenVersion = 0;
+
+/** Latest master tool activity; the oracle's speech bubble shows it. */
 let oracleActivity: string | undefined;
 
-/** Record the master's current activity word (see events.ts); undefined clears it. */
+/** The mounted widget, so run and activity updates can repaint without waiting a tick. */
+let mountedWidget: { refresh(): void } | undefined;
+
+function touch(): void {
+  zenVersion += 1;
+  mountedWidget?.refresh();
+}
+
+/** Record the master's current activity word (see events.ts); undefined means it waits on the user. */
 export function setOracleActivity(activity: string | undefined): void {
+  if (activity === oracleActivity) return;
   oracleActivity = activity;
+  touch();
 }
 
 /** Upper bound on retained runs so a long task cannot grow the widget state without limit. */
-export const MAX_RETAINED_RUNS = 64;
+export const MAX_RETAINED_RUNS = 128;
 
 /**
  * Merge `incoming` runs into `previous`, keyed by `runId`: a newer copy of a run
@@ -46,13 +64,39 @@ export const MAX_RETAINED_RUNS = 64;
  */
 export function mergeRuns(previous: readonly AgentRun[], incoming: readonly AgentRun[]): AgentRun[] {
   if (incoming.length === 0) return [...previous];
-  const merged = [...previous];
+  const merged = new Map<string, AgentRun>();
+  for (const run of previous) merged.set(run.runId, run);
   for (const run of incoming) {
-    const at = merged.findIndex((existing) => existing.runId === run.runId);
-    if (at >= 0) merged.splice(at, 1);
-    merged.push(run);
+    merged.delete(run.runId);
+    merged.set(run.runId, run);
   }
-  return merged.slice(-MAX_RETAINED_RUNS);
+  return [...merged.values()].slice(-MAX_RETAINED_RUNS);
+}
+
+/** The task's persisted worker records as runs, oldest first; the panel only reads their plan fields. */
+export function persistedRuns(task: Task | undefined): AgentRun[] {
+  return (task?.workerRuns ?? []).map((record) => ({
+    runId: record.runId,
+    taskId: task!.id,
+    domain: record.domain,
+    role: "worker",
+    status: record.status,
+    instruction: record.instruction,
+    output: "",
+    attempts: 1,
+    startedAt: record.startedAt,
+    ...(record.finishedAt ? { finishedAt: record.finishedAt } : {}),
+  }));
+}
+
+/** Runs are retained without their report text: the panel never reads it and reports can be large. */
+function slim(runs: readonly AgentRun[]): AgentRun[] {
+  return runs.map((run) => (run.output ? { ...run, output: "" } : run));
+}
+
+function setZenState(task: Task | undefined, live: AgentRun[]): void {
+  zenState = { task, live, runs: mergeRuns(persistedRuns(task), live) };
+  touch();
 }
 
 /** Per-session standard-pi mode: the widget and Master prompt are hidden but ownership stays. */
@@ -69,7 +113,7 @@ export function setMinimized(value: boolean): void {
 /** Flip minimize/restore and refresh the footer; the session is unchanged. */
 export function toggleMinimized(ctx: ExtensionContext, configDir: string): void {
   setMinimized(!minimized);
-  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir, zenState.runs);
+  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir, zenState.live);
   ctx.ui.notify(minimized ? "bot-lobby minimized — ctrl+shift+m or /bot-lobby restore to return" : "bot-lobby restored", "info");
 }
 
@@ -100,6 +144,7 @@ const EXPRESSION_KEYS: readonly ExpressionKey[] = [...SLOT_IDS, "oracle"];
 /** Animated zen scene + plan checklist shown above the editor while a task is active. */
 class ZenWidget implements Component {
   private tick = 0;
+  private cache: { key: string; theme: Theme; lines: string[] } | undefined;
   private delay = liveTickDelay();
   private timer: ReturnType<typeof setInterval>;
   private disposed = false;
@@ -116,6 +161,12 @@ class ZenWidget implements Component {
     const entries = EXPRESSION_KEYS.map((key) => [key, createExpression(now, rng)] as const);
     this.expressions = Object.fromEntries(entries) as Record<ExpressionKey, ExpressionState>;
     this.timer = setInterval(() => this.advance(), this.delay);
+    mountedWidget = this;
+  }
+
+  /** Repaint now: state changed between ticks. */
+  refresh(): void {
+    if (!this.disposed) this.tui.requestRender();
   }
 
   private advance(): void {
@@ -144,18 +195,34 @@ class ZenWidget implements Component {
     return Object.fromEntries(EXPRESSION_KEYS.map((key) => [key, this.expressions[key].frame]));
   }
 
+  /**
+   * 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
+   * output) reuses the last lines instead of recomposing the scene.
+   */
   render(width: number): string[] {
     const now = Date.now();
-    const opts = { width, rows: this.tui.terminal.rows, tick: this.tick, theme: this.theme(), expressions: this.frames(), oracleActivity };
-    const lines = panelLines(zenState.task, zenState.runs, now, isQuiet(), opts);
-    return lines.map((line) => truncateToWidth(line, width));
+    const rows = this.tui.terminal.rows;
+    const theme = this.theme();
+    const expressions = this.frames();
+    const quiet = isQuiet();
+    const frameKey = EXPRESSION_KEYS.map((key) => expressions[key] ?? 0).join(",");
+    const key = `${width}|${rows}|${this.tick}|${frameKey}|${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 };
+    const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => truncateToWidth(line, width));
+    this.cache = { key, theme, lines };
+    return lines;
   }
 
-  invalidate(): void {}
+  invalidate(): void {
+    this.cache = undefined;
+  }
 
   dispose(): void {
     this.disposed = true;
     clearInterval(this.timer);
+    if (mountedWidget === this) mountedWidget = undefined;
   }
 }
 
@@ -176,7 +243,7 @@ export function applyStatus(ctx: ExtensionContext, root: string, configDir: stri
   const sessionId = ctx.sessionManager.getSessionId();
   const task = isSubagentProcess() || minimized ? undefined : activeTask(root, configDir, sessionId);
   const sameTask = zenState.task?.id === task?.id;
-  zenState = { task, runs: mergeRuns(sameTask ? zenState.runs : [], runs) };
+  setZenState(task, mergeRuns(sameTask ? zenState.live : [], slim(runs)));
   ctx.ui.setStatus(STATUS_KEY, statusText(task, minimized));
   const active = Boolean(task && !TERMINAL_STATES.includes(task.state));
   if (!active) {
@@ -192,9 +259,24 @@ export function applyStatus(ctx: ExtensionContext, root: string, configDir: stri
   }
 }
 
+/**
+ * Streamed run updates (start, every activity change, finish) from an in-flight
+ * `orchestrate` call. The task on disk does not change mid-call, so this only
+ * merges the runs and repaints; `applyStatus` rereads the task once the call ends.
+ * Before any task is loaded it falls back to `applyStatus` so the widget appears.
+ */
+export function reportRuns(ctx: ExtensionContext, root: string, configDir: string, runs: AgentRun[]): void {
+  if (!zenState.task && !minimized) {
+    applyStatus(ctx, root, configDir, runs);
+    return;
+  }
+  setZenState(zenState.task, mergeRuns(zenState.live, slim(runs)));
+}
+
 export function clearStatus(ctx: ExtensionContext): void {
   leaveZen(ctx);
   oracleActivity = undefined;
+  zenState = { task: undefined, live: [], runs: [] };
   ctx.ui.setStatus(STATUS_KEY, undefined);
   ctx.ui.setWidget(STATUS_KEY, undefined);
 }
@@ -217,7 +299,7 @@ function revealTools(ctx: ExtensionContext, configDir: string): void {
   const expanded = ctx.ui.getToolsExpanded();
   ctx.ui.setToolsExpanded(!expanded);
   ctx.ui.setToolsExpanded(expanded);
-  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir, zenState.runs);
+  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir, zenState.live);
   ctx.ui.notify(
     quiet
       ? "bot-lobby: tool rows hidden from now on — alt+t reveals them"

package/src/pi/zen-large.ts

@@ -1,7 +1,11 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import {
   BAR,
+  BUBBLE,
+  ORACLE_AURA,
+  ORACLE_AURA_TICKS,
   ORACLE_COLORS,
+  ORACLE_IDLE_WORD,
   ORACLE_FRAMES,
   ORACLE_WORDS,
   SLOT_FRAMES,
@@ -12,6 +16,7 @@ import {
   SPIN_FRAMES,
   TOWER,
   TOWER_DOOR,
+  TOWER_WIDTH,
   type OracleFrame,
   type OraclePose,
   type PanelColor,
@@ -21,8 +26,8 @@ import {
 import type { PanelTheme } from "./zen.ts";
 
 /**
- * The large animated zen scene: a header box, the pulsing oracle tower with its
- * tree connector, the four animated agent columns (face, label, status word and
+ * The large animated zen scene: a header box, the oracle tower with its speech
+ * bubble and tree connector, the four animated agent columns (face, label, status word and
  * elapsed rows), and the TASKS checklist spanning the full scene width (there is
  * no LOG window).
  *
@@ -72,8 +77,10 @@ export interface LargeSceneInput {
   slots: readonly LargeSlot[];
   tasks: readonly LargeTaskRow[];
   oracle: { pose: OraclePose; frame: number };
-  /** Master's live tool activity for the oracle spinner; absent reads "working". */
+  /** 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. */
+  caption?: string;
   /** Approval/blocked line; never dropped when present. */
   alert?: string;
   /** Severity of the alert line: approvals are `warning`, blocked is `error`. */
@@ -98,11 +105,15 @@ const TASK_COLORS: Record<LargeTaskRow["status"], PanelColor> = {
 };
 
 const TOWER_ROWS: Record<TowerSize, number> = {
-  full: TOWER.rows.length + 1,
-  small: TOWER.smallRows.length + 1,
+  full: TOWER.rows.length,
+  small: TOWER.smallRows.length,
   none: 0,
 };
 
+/** Bubble rows: top border, the text lines and the bottom border. */
+const BUBBLE_ROWS = BUBBLE.lines + 2;
+const BUBBLE_TEXT = BUBBLE.width - 4;
+
 const TOWER_PATTERN = new RegExp(
   `(${Object.values(TOWER.tokens).map((token) => token.replace(/([{}])/g, "\\$1")).join("|")})`,
 );
@@ -299,40 +310,99 @@ function oracleFrame(input: LargeSceneInput): OracleFrame {
   return frames[mod(input.oracle.frame, frames.length)]!;
 }
 
+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);
-  const values = new Map<string, string>([
-    [TOWER.tokens.orb, frame.orb],
-    [TOWER.tokens.winL, frame.winL],
-    [TOWER.tokens.winR, frame.winR],
-    [TOWER.tokens.mouth, frame.mouth],
-    [TOWER.tokens.door, input.doorLabel ?? TOWER_DOOR],
-  ]);
   const accent = ORACLE_COLORS[input.oracle.pose];
-  const parts = row.split(TOWER_PATTERN);
-  return parts
-    .map((part) => {
-      const value = values.get(part);
-      return value === undefined ? paint(part, "muted", theme) : paint(value, accent.color, theme, accent.bold);
-    })
+  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 row
+    .split(TOWER_PATTERN)
+    .map((part) => values.get(part)?.() ?? paint(part, "muted", theme))
     .join("");
 }
 
-/** The oracle spinner line: the master's live tool activity, or the dormant word. */
-function oracleLine(input: LargeSceneInput, width: number, theme?: PanelTheme): string {
+/** The bubble's first line: what the oracle is doing right now. */
+export function oracleSpeech(input: LargeSceneInput): string {
+  if (input.oracle.pose !== "orchestrating") return `${SLOT_STATE_GLYPHS.idle} ${ORACLE_WORDS.dormant}`;
+  const spin = SPIN_FRAMES[mod(input.tick, SPIN_FRAMES.length)]!;
+  if (input.oracleActivity) return `${spin} ${input.oracleActivity}`;
+  if (workingLabels(input).length > 0) return `${spin} ${ORACLE_WORDS.orchestrating}`;
+  return `${SLOT_STATE_GLYPHS.idle} ${ORACLE_IDLE_WORD}`;
+}
+
+function workingLabels(input: LargeSceneInput): string[] {
+  return input.slots.filter((slot) => slot.status === "working").map((slot) => slot.label || SLOT_LABELS[slot.id]);
+}
+
+/** The bubble's second line: who is at work, else plan progress while building, else the task phase. */
+export function oracleAside(input: LargeSceneInput): string {
+  const working = workingLabels(input);
+  if (input.oracle.pose === "orchestrating" && working.length > 0) return `→ ${working.join(" · ")}`;
+  const building = /^(implementing|reviewing)\b/.test(input.state);
+  if (building && input.total > 0) {
+    return input.done >= input.total ? "all steps done" : `step ${Math.min(input.done + 1, input.total)} of ${input.total}`;
+  }
+  return input.caption ?? input.state;
+}
+
+/**
+ * The speech bubble beside the crown: a rounded box with `BUBBLE.lines` text
+ * rows. The first text row opens with `┤`, where the tail from the oracle lands.
+ */
+function bubbleRows(input: LargeSceneInput, theme?: PanelTheme): string[] {
   const accent = ORACLE_COLORS[input.oracle.pose];
-  return place(paint(oracleStatusText(input), accent.color, theme, accent.bold), width);
+  const border = (text: string) => paint(text, "muted", theme);
+  const text = (value: string) => padTo(truncateToWidth(value, BUBBLE_TEXT, "…"), BUBBLE_TEXT);
+  const rule = "─".repeat(BUBBLE.width - 2);
+  return [
+    border(`╭${rule}╮`),
+    border("┤ ") + paint(text(oracleSpeech(input)), accent.color, theme, accent.bold) + border(" │"),
+    border("│ ") + paint(text(oracleAside(input)), "muted", theme) + border(" │"),
+    border(`╰${rule}╯`),
+  ];
 }
 
-function oracleStatusText(input: LargeSceneInput): string {
-  if (input.oracle.pose !== "orchestrating") return `${SLOT_STATE_GLYPHS.idle} ${ORACLE_WORDS.dormant}`;
-  return `${SPIN_FRAMES[mod(input.tick, SPIN_FRAMES.length)]!} ${input.oracleActivity ?? "working"}`;
+/** Row where the bubble starts: its tail row lines up with the crown orb where there is room. */
+function bubbleStart(rows: readonly string[]): number {
+  const orb = rows.findIndex((row) => row.includes(TOWER.tokens.orb));
+  return clamp(orb - 1, 0, Math.max(0, rows.length - BUBBLE_ROWS));
+}
+
+/**
+ * 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 {
+  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);
 }
 
 function towerLines(input: LargeSceneInput, width: number, theme: PanelTheme | undefined, size: TowerSize): string[] {
   if (size === "none") return [];
   const rows = size === "small" ? TOWER.smallRows : TOWER.rows;
-  return [oracleLine(input, width, theme), ...rows.map((row) => place(towerRow(row, input, theme), width))];
+  const left = " ".repeat(sceneLeft(width) + Math.floor((SCENE_WIDTH - TOWER_WIDTH) / 2));
+  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)} `;
+    return left + tower + speech;
+  });
 }
 
 function stripWidth(count: number): number {

package/src/pi/zen.ts

@@ -67,9 +67,12 @@ const PREFIX_CHARS = 32;
 const MIN_PREFIX = 8;
 const HEADER_LINE = /^\s*(?:#{1,6}\s+\S.*|\*\*[^*]+\*\*)\s*$/;
 const STEP_SECTION = /sequence|steps|order/i;
-const NUMBERED_STEP_LINE = /^\s*\d+[.)]\s+(.*\S)\s*$/;
-const INDENTED_BULLET = /^\s*[*-]\s+(.*\S)\s*$/;
-const TOP_LEVEL_BULLET = /^[*-]\s+(.*\S)\s*$/;
+const NUMBERED_STEP_LINE = /^(\s*)(\d+[.)])\s+(.*\S)\s*$/;
+const BULLET_LINE = /^(\s*)([*-])\s+(.*\S)\s*$/;
+const TOP_LEVEL_BULLET = /^()([*-])\s+(.*\S)\s*$/;
+/** `### Step 2: Wire the API`, `**Step 2 — Wire the API**`, `Phase 3) Tests`: one plan step per heading. */
+const STEP_HEADING = /^\s*(?:#{1,6}\s+)?(?:\*\*)?\s*(?:step|phase|stage)\s+#?\d+\s*(?:\*\*)?\s*[:.)\u2014\u2013-]\s*(?:\*\*)?\s*(.*?)\s*(?:\*\*)?\s*$/i;
+const MIN_STEP_HEADINGS = 2;
 
 export type PlanStepStatus = "done" | "current" | "pending";
 
@@ -78,20 +81,54 @@ export interface PlanStep {
   status: PlanStepStatus;
 }
 
-/** Numbered `1.`/`1)` text, or a bullet inside a step section; undefined otherwise. */
-function stepText(line: string): string | undefined {
-  return NUMBERED_STEP_LINE.exec(line)?.[1] ?? INDENTED_BULLET.exec(line)?.[1];
+interface ListItem {
+  indent: number;
+  /** Column where the item's text starts; deeper items are nested under it. */
+  content: number;
+  text: string;
 }
 
-function topBulletText(line: string): string | undefined {
-  return TOP_LEVEL_BULLET.exec(line)?.[1];
+type ItemMatcher = (line: string) => ListItem | undefined;
+
+function indentOf(line: string): number {
+  return /^\s*/.exec(line)![0].replace(/\t/g, "    ").length;
 }
 
-function collectSteps(lines: readonly string[], accept: (line: string) => string | undefined): string[] {
+function itemMatcher(pattern: RegExp): ItemMatcher {
+  return (line) => {
+    const match = pattern.exec(line);
+    if (!match) return undefined;
+    const indent = indentOf(match[1]!);
+    return { indent, content: indent + match[2]!.length + 1, text: match[3]! };
+  };
+}
+
+const numberedItem = itemMatcher(NUMBERED_STEP_LINE);
+const bulletItem = itemMatcher(BULLET_LINE);
+const topBulletItem = itemMatcher(TOP_LEVEL_BULLET);
+
+/** Numbered `1.`/`1)` text, or a bullet inside a step section; undefined otherwise. */
+function sectionItem(line: string): ListItem | undefined {
+  return numberedItem(line) ?? bulletItem(line);
+}
+
+/**
+ * Top-level list items only. As in CommonMark, an item indented to its parent's
+ * text column is a sub-point of that step, so nested bullets or a nested `1.`
+ * list never inflate the checklist. Prose at a shallower indent ends the parent.
+ */
+function collectSteps(lines: readonly string[], accept: ItemMatcher): string[] {
   const found: string[] = [];
+  let parent: number | undefined;
   for (const line of lines) {
-    const text = accept(line);
-    if (text !== undefined) found.push(text);
+    const item = accept(line);
+    if (!item) {
+      if (parent !== undefined && line.trim() && indentOf(line) < parent) parent = undefined;
+      continue;
+    }
+    if (parent !== undefined && item.indent >= parent) continue;
+    found.push(item.text);
+    parent = item.content;
   }
   return found;
 }
@@ -108,37 +145,143 @@ function stepSection(lines: readonly string[]): string[] | undefined {
   return body;
 }
 
+/** `Step N` headings, when the plan is structured as one heading per step. */
+function headingSteps(lines: readonly string[]): string[] {
+  const found: string[] = [];
+  for (const line of lines) {
+    const match = STEP_HEADING.exec(line);
+    if (match) found.push(match[1] || line.replace(/[#*]/g, "").trim());
+  }
+  return found.length >= MIN_STEP_HEADINGS ? found : [];
+}
+
 /**
- * Step texts from a free-form plan, capped. A `sequence|steps|order` section wins; otherwise
- * numbered lines win; when neither exists, top-level bullets are the last resort, so unrelated
- * bullet lists under other headers never leak into the checklist.
+ * Step texts from a free-form plan, capped. `Step N` headings win; then a
+ * `sequence|steps|order` section; then numbered lines; when none exists,
+ * top-level bullets are the last resort, so unrelated bullet lists under other
+ * headers never leak into the checklist. Only the shallowest items count.
  */
 export function planSteps(plan: string): string[] {
   const lines = plan.split("\n");
+  const headings = headingSteps(lines);
+  if (headings.length > 0) return headings.slice(0, MAX_PLAN_STEPS);
   const section = stepSection(lines);
   if (section) {
-    const sectioned = collectSteps(section, stepText);
+    const sectioned = collectSteps(section, sectionItem);
     if (sectioned.length > 0) return sectioned.slice(0, MAX_PLAN_STEPS);
   }
-  const numbered = collectSteps(lines, (line) => NUMBERED_STEP_LINE.exec(line)?.[1]);
+  const numbered = collectSteps(lines, numberedItem);
   if (numbered.length > 0) return numbered.slice(0, MAX_PLAN_STEPS);
-  return collectSteps(lines, topBulletText).slice(0, MAX_PLAN_STEPS);
+  return collectSteps(lines, topBulletItem).slice(0, MAX_PLAN_STEPS);
 }
 
+/* -------------------------------------------------------------------------
+ * Step matching. A worker instruction names its step explicitly ("Step 3: ...")
+ * or is scored against every step by shared paths, a shared opening phrase and
+ * word overlap. Plans reuse file paths across steps, so near-ties go to the
+ * earliest step still open instead of the first step that ever mentioned the
+ * path -- otherwise every later instruction re-matches step 1 and the tracker
+ * never moves.
+ * ---------------------------------------------------------------------- */
+
+const STEP_REFERENCE = /\bsteps?\s*#?\s*(\d+)(?:\s*(?:-|\u2013|\u2014|to|through|thru|and|&)\s*#?\s*(\d+))?/gi;
+/** Text allowed before a step reference that labels the instruction itself ("Now implement step 3:"). */
+const LEADING_LABEL = /^[\s\W]*(?:(?:now|next|then|please|implement|do|complete|execute|start|begin|finish|work on|continue with|proceed with|plan)\s+)*(?:the\s+)?$/i;
+const MIN_SCORE = 0.5;
+const NEAR_TIE = 0.35;
+const PATH_WEIGHT = 0.75;
+const PREFIX_WEIGHT = 1;
+const WORD = /[a-z0-9_][a-z0-9_./-]*[a-z0-9_]/g;
+const MIN_WORD = 3;
+const STOP_WORDS = new Set([
+  "the", "and", "for", "with", "that", "this", "from", "into", "then", "when", "each", "use", "make",
+  "sure", "new", "all", "any", "its", "are", "not", "but", "now", "via", "per", "our", "your", "you",
+  "has", "have", "will", "should", "must", "also", "only", "step", "steps", "plan", "approved",
+  "implement", "please", "add", "update", "change", "changes", "file", "files", "code",
+]);
+
 function normalize(text: string): string {
   return text.replace(/[`*_]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
 
-function matchesInstruction(step: string, instruction: string): boolean {
-  const hay = normalize(instruction);
-  const path = /`([^`]+)`/.exec(step)?.[1];
-  if (path && hay.includes(normalize(path))) return true;
-  const tail = normalize(step.replace(/`[^`]+`/g, " ").replace(/^[\s:;,.—–-]+/, ""));
+function significantWords(text: string): Set<string> {
+  const words = new Set<string>();
+  for (const word of normalize(text).match(WORD) ?? []) {
+    if (word.length >= MIN_WORD && !STOP_WORDS.has(word)) words.add(word);
+  }
+  return words;
+}
+
+/** Scoring context for one instruction, built once per run and reused for every step. */
+interface InstructionIndex {
+  text: string;
+  words: Set<string>;
+}
+
+function indexInstruction(instruction: string): InstructionIndex {
+  return { text: normalize(instruction), words: significantWords(instruction) };
+}
+
+function prefixMatches(step: string, hay: string): boolean {
+  const tail = normalize(step.replace(/`[^`]+`/g, " ").replace(/^[\s:;,.\u2014\u2013-]+/, ""));
   return tail.length >= MIN_PREFIX && hay.includes(tail.slice(0, PREFIX_CHARS));
 }
 
+function pathShare(step: string, hay: string): number {
+  const paths = [...step.matchAll(/`([^`]+)`/g)].map((match) => normalize(match[1]!)).filter((path) => path.length > 0);
+  if (paths.length === 0) return 0;
+  return paths.filter((path) => hay.includes(path)).length / paths.length;
+}
+
+function wordShare(step: string, words: ReadonlySet<string>): number {
+  const own = significantWords(step);
+  if (own.size === 0) return 0;
+  let shared = 0;
+  for (const word of own) if (words.has(word)) shared += 1;
+  return shared / own.size;
+}
+
+/** How strongly an instruction targets one step; 0 when it shares nothing. */
+function stepScore(step: string, instruction: InstructionIndex): number {
+  const prefix = prefixMatches(step, instruction.text) ? PREFIX_WEIGHT : 0;
+  return prefix + PATH_WEIGHT * pathShare(step, instruction.text) + wordShare(step, instruction.words);
+}
+
+/**
+ * Highest 0-based step an instruction labels itself with ("Step 3: ...", "steps 2-4"),
+ * or -1. A reference counts when it opens the instruction or is the only one
+ * named, so "building on step 1, now do step 3" does not jump back to step 1.
+ */
+export function explicitStepIndex(instruction: string, count: number): number {
+  const refs = [...instruction.matchAll(STEP_REFERENCE)];
+  if (refs.length === 0) return -1;
+  const first = refs[0]!;
+  const leading = LEADING_LABEL.test(instruction.slice(0, first.index ?? 0)) ? first : undefined;
+  const distinct = new Set(refs.map((ref) => ref[0].toLowerCase().replace(/\s+/g, "")));
+  const chosen = leading ?? (distinct.size === 1 ? refs[0] : undefined);
+  if (!chosen) return -1;
+  const last = Math.max(Number(chosen[1]), Number(chosen[2] ?? chosen[1]));
+  return last >= 1 && last <= count ? last - 1 : -1;
+}
+
+/**
+ * The step an instruction targets, given the steps already completed; -1 when
+ * nothing matches. Among near-tied candidates the earliest open step wins.
+ */
+export function targetStep(steps: readonly string[], instruction: string | undefined, completed: ReadonlySet<number> = new Set()): number {
+  if (!instruction || steps.length === 0) return -1;
+  const explicit = explicitStepIndex(instruction, steps.length);
+  if (explicit >= 0) return explicit;
+  const index = indexInstruction(instruction);
+  const scores = steps.map((step) => stepScore(step, index));
+  const best = Math.max(...scores);
+  if (best < MIN_SCORE) return -1;
+  const near = scores.findIndex((score, at) => score >= best - NEAR_TIE && score >= MIN_SCORE && !completed.has(at));
+  return near >= 0 ? near : scores.indexOf(best);
+}
+
 /** The latest worker run carrying an instruction; its step is the current one. */
-export function latestWorkerRun(runs: AgentRun[]): AgentRun | undefined {
+export function latestWorkerRun(runs: readonly AgentRun[]): AgentRun | undefined {
   let latest: AgentRun | undefined;
   for (const run of runs) {
     if (run.role !== "worker" || !run.instruction) continue;
@@ -147,11 +290,6 @@ export function latestWorkerRun(runs: AgentRun[]): AgentRun | undefined {
   return latest;
 }
 
-/** Index of the plan step an instruction targets, -1 when nothing matches. */
-export function currentStepIndex(steps: readonly string[], instruction: string | undefined): number {
-  return instruction ? steps.findIndex((step) => matchesInstruction(step, instruction)) : -1;
-}
-
 function stepStatus(index: number, current: number): PlanStepStatus {
   if (current < 0) return index === 0 ? "current" : "pending";
   if (index < current) return "done";
@@ -168,37 +306,58 @@ function markThrough(completed: Set<number>, index: number): void {
   for (let step = 0; step <= index; step += 1) completed.add(step);
 }
 
+function byStart(runs: readonly AgentRun[]): AgentRun[] {
+  const time = (run: AgentRun) => {
+    const at = Date.parse(run.startedAt);
+    return Number.isFinite(at) ? at : 0;
+  };
+  return runs
+    .map((run, order) => ({ run, order }))
+    .sort((a, b) => time(a.run) - time(b.run) || a.order - b.order)
+    .map((entry) => entry.run);
+}
+
 /**
- * Steps completed by successful worker runs, in start order. A run whose instruction matches
- * a step completes everything up to that step; a run that matches nothing -- the common case
- * for a reworded instruction -- completes the next still-open step, so the count only grows
- * and a failure can never tick one off.
+ * Replays worker runs in start order. A successful run completes everything up
+ * to its target step; a run that matches nothing -- the common case for a
+ * reworded instruction -- completes the next still-open step, so the count only
+ * grows and a failure can never tick one off. The latest worker run's own target
+ * is reported separately so a running or failed step reads current.
  */
-function completedSteps(steps: readonly string[], runs: AgentRun[]): number {
+function replaySteps(steps: readonly string[], runs: readonly AgentRun[]): { completed: number; latest: number } {
   const completed = new Set<number>();
-  for (const run of runs) {
-    if (run.role !== "worker" || run.status !== "success") continue;
-    const matched = currentStepIndex(steps, run.instruction);
+  const latestRun = latestWorkerRun(runs);
+  let latest = -1;
+  for (const run of byStart(runs)) {
+    if (run.role !== "worker") continue;
+    const matched = targetStep(steps, run.instruction, completed);
+    if (run === latestRun) latest = matched >= 0 && run.status === "success" ? matched + 1 : matched;
+    if (run.status !== "success") continue;
     const target = matched >= 0 ? matched : nextOpenStep(steps, completed);
     if (target >= 0) markThrough(completed, target);
   }
-  return completed.size;
+  return { completed: completed.size, latest };
 }
 
+/** One-entry memo: the panel asks for the same checklist several times per frame. */
+let checklistMemo: { plan: string; runs: readonly AgentRun[]; steps: PlanStep[] } | undefined;
+
 /**
- * Done/current/pending per plan step, matched from the latest worker instruction.
- * A succeeded run completes its step, so the next step becomes current (and the
- * last step reads done); running, failed, cancelled and timeout runs keep it current.
- * Progress is monotonic: steps already completed by successful worker runs stay done,
- * and a later call that names an earlier step can never tick it back.
+ * Done/current/pending per plan step. A succeeded run completes its step, so the
+ * next step becomes current (and the last step reads done); running, failed,
+ * cancelled and timeout runs keep it current. Progress is monotonic: steps
+ * already completed by successful worker runs stay done, and a later call that
+ * names an earlier step can never tick it back. Memoized on the exact plan text
+ * and runs array, so callers must not mutate either.
  */
-export function planChecklist(plan: string, runs: AgentRun[]): PlanStep[] {
-  const steps = planSteps(plan);
-  const latest = latestWorkerRun(runs);
-  const matched = currentStepIndex(steps, latest?.instruction);
-  const latestCurrent = matched >= 0 ? (latest?.status === "success" ? matched + 1 : matched) : -1;
-  const current = Math.max(completedSteps(steps, runs), latestCurrent);
-  return steps.map((text, index) => ({ text, status: stepStatus(index, current) }));
+export function planChecklist(plan: string, runs: readonly AgentRun[]): PlanStep[] {
+  if (checklistMemo && checklistMemo.plan === plan && checklistMemo.runs === runs) return checklistMemo.steps;
+  const texts = planSteps(plan);
+  const replay = replaySteps(texts, runs);
+  const current = Math.max(replay.completed, replay.latest);
+  const steps = texts.map((text, index) => ({ text, status: stepStatus(index, current) }));
+  checklistMemo = { plan, runs, steps };
+  return steps;
 }
 
 /** Up to `count` consecutive step indexes centered on the current step, hard-capped at `max`. */
@@ -211,7 +370,7 @@ export function checklistWindow(steps: readonly PlanStep[], count: number, max =
   return Array.from({ length: size }, (_value, offset) => start + offset);
 }
 
-function stepLine(step: PlanStep, ordinal: number): string {
+function checklistRow(step: PlanStep, ordinal: number): string {
   const icon = step.status === "done" ? "✓" : step.status === "current" ? "◐" : "○";
   return `  ${icon} ${ordinal}. ${step.text}`;
 }
@@ -329,7 +488,7 @@ function tailLines(task: Task, runs: AgentRun[], now: number, tick: number, step
 
 function checklistLines(steps: PlanStep[], count: number): string[] {
   if (steps.length === 0 || count <= 0) return [];
-  return checklistWindow(steps, count).map((index) => stepLine(steps[index]!, index + 1));
+  return checklistWindow(steps, count).map((index) => checklistRow(steps[index]!, index + 1));
 }
 
 function compactPanel(
@@ -415,6 +574,7 @@ function sceneInput(
     tasks: sceneTasks(steps),
     oracle: oracleSlot(task, expressions),
     oracleActivity,
+    caption: task.paused ? "task paused" : SCENE_PROPS[task.state],
     alert: alert?.text,
     alertKind: alert?.kind,
   };
@@ -429,7 +589,7 @@ export interface PanelOptions {
   theme?: PanelTheme;
   /** Caller-scheduled expression frame per slot and the oracle; absent means rest. */
   expressions?: ExpressionFrames;
-  /** Live master activity word for the oracle spinner; absent reads "working". */
+  /** Live master activity word for the oracle's speech bubble; absent means it waits on the user. */
   oracleActivity?: string;
 }
 

package/src/schemas/task.ts

@@ -54,6 +54,22 @@ export interface ReviewRecord {
   requiredChanges: string[];
   createdAt: string;
 }
+/**
+ * One finished worker delegation, kept on the task so the plan checklist can be
+ * replayed after a reload instead of resetting to the first step.
+ */
+export interface WorkerRunRecord {
+  runId: string;
+  domain: Domain;
+  instruction: string;
+  status: "running" | "success" | "failed" | "cancelled" | "timeout";
+  startedAt: string;
+  finishedAt?: string;
+}
+
+/** Upper bound on persisted worker records; plans cap at 50 steps. */
+export const MAX_WORKER_RECORDS = 64;
+
 export interface Task {
   id: string;
   title: string;
@@ -71,6 +87,8 @@ export interface Task {
   blockers: Blocker[];
   decisions: Decision[];
   approvals: Approval[];
+  /** Worker delegations in start order; absent on tasks created before tracking. */
+  workerRuns?: WorkerRunRecord[];
   createdAt: string;
   updatedAt: string;
   /** The pi session (ctx.sessionManager id) that owns this task; absent on legacy tasks. */

package/src/workflow/workflow.ts

@@ -1,7 +1,17 @@
 import { join } from "node:path";
 import type { BotLobbyConfig } from "../schemas/configuration.ts";
 import type { AgentRun, Pushback, ResearchResult, ReviewResult } from "../schemas/findings.ts";
-import { TASK_STATES, TERMINAL_STATES, taskRequest, type Approval, type ApprovalKind, type Task, type TaskState } from "../schemas/task.ts";
+import {
+  MAX_WORKER_RECORDS,
+  TASK_STATES,
+  TERMINAL_STATES,
+  taskRequest,
+  type Approval,
+  type ApprovalKind,
+  type Task,
+  type TaskState,
+  type WorkerRunRecord,
+} from "../schemas/task.ts";
 import { isDomain, type Domain } from "../schemas/agent.ts";
 import { transition } from "../state/task-state.ts";
 import { ownerlessTask, readTaskArtifact, removeTaskScratchpads, saveTask, selectTask, taskDirFor, taskReadDirs } from "../state/persistence.ts";
@@ -495,6 +505,19 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
   };
 }
 
+/** Remember a worker delegation so the checklist replays it after a reload. */
+function recordWorkerRun(task: Task, run: AgentRun): void {
+  const record: WorkerRunRecord = {
+    runId: run.runId,
+    domain: run.domain,
+    instruction: run.instruction ?? "",
+    status: run.status,
+    startedAt: run.startedAt,
+    ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+  };
+  task.workerRuns = [...(task.workerRuns ?? []), record].slice(-MAX_WORKER_RECORDS);
+}
+
 async function handleImplement(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
   requireState(task, ["planning", "implementing", "reviewing"]);
   const domain = parseDomain(params.domain, "implement");
@@ -504,6 +527,7 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   if (!task.domains.includes(domain)) task.domains.push(domain);
   if (task.state !== "implementing") transition(task, "implementing");
   const outcome = await runWorker(workerRequest(deps, task, domain, instruction), deps.runProcess ?? spawnPiProcess);
+  recordWorkerRun(task, outcome.run);
   const approvals = recordWorkerApprovals(task, outcome, deps.config);
   const pushback = recordPushback(task, outcome);
   task.blockers = [...task.blockers.filter((blocker) => blocker.domain !== domain), ...outcome.result.blockers];