@a-t-h-i/bot-lobby 0.6.5 → 0.6.7

package/src/lobby/feed.ts

@@ -2,7 +2,7 @@
  * What the lobby narrates: an activity log of plain-words tool steps from the
  * Master and every subagent, a single place for thoughts, and the conversation
  * with the Master stripped of tool rows and thinking. Bounded ring buffers in
- * one module-level store (like the zen widget state), so every event source can
+ * one module-level store (like the task state in ui.ts), so every event source can
  * write without a reference to the lobby, and the lobby repaints on `version`.
  */
 import type { AgentRun } from "../schemas/findings.ts";
@@ -70,6 +70,8 @@ export class LobbyFeed {
   private readonly runSteps = new Map<string, string>();
   private readonly runThoughts = new Map<string, string>();
   private readonly runStatus = new Map<string, AgentRun["status"]>();
+  /** Runs already reported as switched to their fallback model. */
+  private readonly fellBack = new Set<string>();
 
   onChange(listener: () => void): () => void {
     this.listeners.add(listener);
@@ -200,6 +202,10 @@ export class LobbyFeed {
       const before = this.runStatus.get(key);
       this.runStatus.set(key, run.status);
       if (before === undefined) this.log(source, `started as ${run.role}`, "info", at);
+      if (run.fellBackFrom && !this.fellBack.has(key)) {
+        this.fellBack.add(key);
+        this.log(source, `${run.fellBackFrom} is out of usage or unavailable: running on the fallback model`, "warning", at);
+      }
       if (run.step && this.runSteps.get(key) !== run.step) {
         this.runSteps.set(key, run.step);
         this.step(source, run.step, key, at);
@@ -225,6 +231,7 @@ export class LobbyFeed {
     this.runSteps.clear();
     this.runThoughts.clear();
     this.runStatus.clear();
+    this.fellBack.clear();
     this.touch();
   }
 }

package/src/lobby/keys.ts

@@ -17,7 +17,6 @@ export const LOBBY_ACTIONS = {
   toggleAuto: { key: "alt+g", help: "auto mode: the oracle drives the task to completion without asking" },
   nextTab: { key: "tab", help: "next tab" },
   prevTab: { key: "shift+tab", help: "previous tab" },
-  toggleScene: { key: "alt+z", help: "show or hide the oracle and agent animations" },
   toggleConversation: { key: "alt+c", help: "show or hide the conversation" },
   toggleActivity: { key: "alt+a", help: "show or hide the activity log" },
   toggleThinking: { key: "alt+k", help: "show or hide thinking" },

package/src/lobby/layout.ts

@@ -268,6 +268,24 @@ export function scrollThumb(total: number, rows: number, start: number): { from:
   return { from, to: from + size };
 }
 
+/** Page buttons in the bottom border of a pane that scrolls: two pages up, one up, one down, two down. */
+export const PAGER = "▲▲ ▲ ▼ ▼▼";
+/** Columns the pager takes with a space on each side. */
+export const PAGER_WIDTH = PAGER.length + 2;
+/** Narrowest box that has room for the pager beside its corners. */
+const PAGER_MIN_WIDTH = PAGER_WIDTH + 6;
+
+/** Which page button a column of a scrollable pane's bottom border is: -2, -1, 1 or 2 pages (negative up), or undefined. */
+export function pagerButton(width: number, column: number): -2 | -1 | 1 | 2 | undefined {
+  if (width < PAGER_MIN_WIDTH) return undefined;
+  const from = column - width;
+  if (from >= -12 && from <= -10) return -2;
+  if (from >= -9 && from <= -7) return -1;
+  if (from >= -6 && from <= -5) return 1;
+  if (from >= -4 && from <= -2) return 2;
+  return undefined;
+}
+
 /**
  * A rounded panel exactly `width` × `height`: the title set into the top
  * border, `content` inside with one column of padding, extra lines cut and
@@ -291,7 +309,10 @@ export function box(width: number, height: number, content: readonly string[], o
   const thumb = options.scroll ? scrollThumb(options.scroll.total, height - 2, options.scroll.start) : undefined;
   const rightEdge = (row: number) => (thumb && row >= thumb.from && row < thumb.to ? paint(theme, focused ? "accent" : "muted", "┃") : edge("│"));
   const rows = fill(content, height - 2).map((line, row) => `${edge("│")} ${fit(line, inner)} ${rightEdge(row)}`);
-  return [top, ...rows, `${edge("╰")}${edge("─".repeat(width - 2))}${edge("╯")}`];
+  // A pane with more lines than rows carries page buttons in its bottom border; `pagerButton` finds them again for clicks.
+  const pager = thumb && width >= PAGER_MIN_WIDTH ? ` ${PAGER} ` : "";
+  const bottom = `${edge("╰")}${edge("─".repeat(width - 2 - textWidth(pager)))}${pager ? paint(theme, focused ? "accent" : "muted", pager) : ""}${edge("╯")}`;
+  return [top, ...rows, bottom];
 }
 
 /** Lay boxes out side by side, each already exactly its width and the same height. */

package/src/lobby/mini.ts

@@ -0,0 +1,159 @@
+/**
+ * The one-line status shown under pi's editor while the lobby is hidden: a
+ * small graphic of where the work stands — the task's plan steps (or its stage
+ * before there is a plan), the planning rounds, the quick fix in hand — or a
+ * quiet "idle". Pure: everything it shows arrives as input.
+ */
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { AgentRun } from "../schemas/findings.ts";
+import type { Task, TaskState } from "../schemas/task.ts";
+import { planChecklist } from "../pi/plan-checklist.ts";
+import { agentName } from "../pi/run-summary.ts";
+import { paint, type LobbyTheme } from "./layout.ts";
+
+export interface MiniPlanning {
+  /** A round is running. */
+  busy: boolean;
+  /** The round in hand, and the limit (0 = unlimited). */
+  round: number;
+  limit: number;
+  /** Questions waiting for the user. */
+  questions: number;
+  /** The oracle's draft is ready to save. */
+  ready: boolean;
+  /** The plan was saved as a pending task. */
+  saved: boolean;
+}
+
+export interface MiniQuickFix {
+  title: string;
+  running: boolean;
+  queued: number;
+}
+
+export interface MiniInput {
+  task?: Task;
+  runs: readonly AgentRun[];
+  planning?: MiniPlanning;
+  quickfix?: MiniQuickFix;
+  /** The key that opens the lobby, as shown. */
+  key: string;
+}
+
+/** A full-workflow task's stages, in order, for the strip shown before its plan has steps. */
+const STAGES: readonly TaskState[] = ["clarifying", "scouting", "synthesizing", "awaiting_approval", "planning", "implementing", "reviewing"];
+
+/** Widest step bar; longer plans share its cells. */
+const MAX_CELLS = 12;
+
+/** `■■◐□□`: the plan's steps done, current and to do, squeezed into at most `MAX_CELLS` cells. */
+export function stepBar(statuses: readonly ("done" | "current" | "pending")[]): string {
+  if (statuses.length === 0) return "";
+  const cells = Math.min(statuses.length, MAX_CELLS);
+  const out: string[] = [];
+  for (let cell = 0; cell < cells; cell += 1) {
+    const from = Math.floor((cell * statuses.length) / cells);
+    const to = Math.max(from + 1, Math.floor(((cell + 1) * statuses.length) / cells));
+    const slice = statuses.slice(from, to);
+    out.push(slice.every((status) => status === "done") ? "■" : slice.some((status) => status === "current") ? "◐" : slice.some((status) => status === "done") ? "◐" : "□");
+  }
+  return out.join("");
+}
+
+/** `●●◐○○○○`: how far along the workflow a task without a plan yet is. */
+export function stageBar(state: TaskState): string {
+  const at = STAGES.indexOf(state);
+  if (at < 0) return "";
+  return STAGES.map((_stage, index) => (index < at ? "●" : index === at ? "◐" : "○")).join("");
+}
+
+/** `■■□□□` for `round` of `limit`, or empty without a limit. */
+function roundBar(round: number, limit: number): string {
+  if (limit <= 0) return "";
+  const done = Math.min(limit, Math.max(0, round));
+  return "■".repeat(done) + "□".repeat(limit - done);
+}
+
+const STATE_WORDS: Partial<Record<TaskState, string>> = {
+  awaiting_approval: "awaiting your approval",
+};
+
+function taskSegment(input: MiniInput, theme?: LobbyTheme): string | undefined {
+  const task = input.task;
+  if (!task || task.state === "completed" || task.state === "abandoned") return undefined;
+  const steps = task.plan ? planChecklist(task.plan, input.runs) : [];
+  const done = steps.filter((step) => step.status === "done").length;
+  const bar = steps.length > 0 ? `${stepBar(steps.map((step) => step.status))} ${done}/${steps.length}` : stageBar(task.state);
+  const state = task.paused ? `${task.state} (paused)` : STATE_WORDS[task.state] ?? task.state;
+  const running = [...input.runs].reverse().find((run) => run.status === "running");
+  const doing = running ? ` · ${agentName(running)}${running.activity ? ` ${running.activity}` : ""}` : "";
+  const alert = task.state === "awaiting_approval" || task.paused;
+  return `${paint(theme, "accent", task.id)} ${paint(theme, "success", bar)} ${paint(theme, alert ? "warning" : "muted", state)}${paint(theme, "dim", doing)}`;
+}
+
+function planningSegment(planning: MiniPlanning | undefined, theme?: LobbyTheme): string | undefined {
+  if (!planning || planning.saved) return undefined;
+  const rounds = roundBar(planning.round, planning.limit);
+  const head = `${paint(theme, "accent", "planning")} ${paint(theme, "success", rounds || `round ${planning.round}`)}${rounds ? paint(theme, "muted", ` ${planning.round}/${planning.limit}`) : ""}`;
+  if (planning.questions > 0) return `${head} ${paint(theme, "warning", `● ${planning.questions} question${planning.questions === 1 ? "" : "s"} for you`)}`;
+  if (planning.busy) return `${head} ${paint(theme, "muted", "the panel is thinking")}`;
+  if (planning.ready) return `${head} ${paint(theme, "success", "plan ready to save")}`;
+  return head;
+}
+
+function quickFixSegment(quickfix: MiniQuickFix | undefined, theme?: LobbyTheme): string | undefined {
+  if (!quickfix) return undefined;
+  const queued = quickfix.queued > 0 ? ` +${quickfix.queued} queued` : "";
+  return `${paint(theme, "accent", "quick fix")} ${paint(theme, "success", quickfix.running ? "◐" : "○")} ${paint(theme, "muted", quickfix.title)}${paint(theme, "dim", queued)}`;
+}
+
+/** The status line, at most `width` columns. */
+export function miniLine(input: MiniInput, width: number, theme?: LobbyTheme): string {
+  if (width < 12) return "";
+  const segments = [taskSegment(input, theme), planningSegment(input.planning, theme), quickFixSegment(input.quickfix, theme)].filter((segment): segment is string => Boolean(segment));
+  const body = segments.length > 0 ? segments.join(paint(theme, "dim", "  │  ")) : paint(theme, "dim", "idle");
+  const hint = paint(theme, "dim", `  ${input.key} opens`);
+  const line = ` ${paint(theme, "accent", "◆ bot-lobby")}  ${body}`;
+  return truncateToWidth(`${line}${hint}`, width, "…");
+}
+
+/** An agent at work right now, for the lobby's bottom-line indicator. */
+export interface WorkingAgent {
+  name: string;
+  activity?: string;
+  /** Epoch ms it started, for its elapsed time. */
+  since?: number;
+}
+
+/** The subagents running now: task runs still going, and the quick fix in hand. */
+export function workingAgents(runs: readonly AgentRun[], quickFix?: { startedAt?: number }): WorkingAgent[] {
+  const agents: WorkingAgent[] = [];
+  for (const run of runs) {
+    if (run.status !== "running") continue;
+    const since = Date.parse(run.startedAt);
+    agents.push({ name: agentName(run), ...(run.activity ? { activity: run.activity } : {}), ...(Number.isFinite(since) ? { since } : {}) });
+  }
+  if (quickFix) agents.push({ name: "QUICK FIX", ...(quickFix.startedAt ? { since: quickFix.startedAt } : {}) });
+  return agents;
+}
+
+function elapsed(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m`;
+}
+
+/**
+ * `◐ DESIGN editing 2m · DEV running 40s`, at most `width` columns: it gives up
+ * the activity and time, then the names, then shows only a count, and nothing
+ * when even that does not fit or nothing is working. `spin` is the spinner glyph.
+ */
+export function agentsIndicator(agents: readonly WorkingAgent[], now: number, spin: string, width: number, theme?: LobbyTheme): string {
+  if (agents.length === 0) return "";
+  const full = agents.map((agent) => `${agent.name}${agent.activity ? ` ${agent.activity}` : ""}${agent.since ? ` ${elapsed(now - agent.since)}` : ""}`).join(" · ");
+  const names = [...new Set(agents.map((agent) => agent.name))].join(" · ");
+  const count = `${agents.length} agent${agents.length === 1 ? "" : "s"} working`;
+  for (const text of [full, names, count]) {
+    if (text.length + 2 <= width) return `${paint(theme, "accent", spin)} ${paint(theme, "muted", text)}`;
+  }
+  return "";
+}

package/src/lobby/planner.ts

@@ -20,6 +20,7 @@
  */
 import { loadPrompt } from "../prompts/loader.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
+import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
@@ -593,12 +594,12 @@ export class PlanningSession {
     const startedAt = Date.now();
     let outcome: RunOutcome;
     try {
-      const result = await runPiAgent(
+      const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
           ...request,
-          model: profile.model,
-          thinking: profile.thinking,
+          model,
+          thinking,
           timeoutMs: profile.timeoutMs,
           signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
@@ -607,6 +608,12 @@ export class PlanningSession {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
+      // A model that is out of usage hands the turn to the fallback the settings name.
+      const { result, switchedFrom } = await withFallback(profile.model, profile.thinking, profile.fallback, attempt);
+      if (switchedFrom && profile.fallback) {
+        this.deps.feed?.log(label, `${switchedFrom} is out of usage or unavailable; ran on ${profile.fallback.model}`, "warning");
+        profile = { ...profile, model: profile.fallback.model, thinking: profile.fallback.thinking };
+      }
       outcome = { status: result.status, output: result.output, ...(result.error ? { error: result.error } : {}), ...(result.model ? { model: result.model } : {}), usage: result.usage };
     } catch (error) {
       outcome = { status: "failed", output: "", error: (error as Error).message, usage: { input: 0, output: 0, cost: 0, turns: 0 } };

package/src/lobby/quickfix.ts

@@ -6,6 +6,7 @@
  * and the lobby feed, and every finished job lands in the metrics log.
  */
 import { loadPrompt } from "../prompts/loader.ts";
+import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
@@ -74,6 +75,8 @@ export interface QuickFixProfile {
   thinking: string;
   timeoutMs: number;
   instructions?: string;
+  /** Where the job goes when its model runs out of usage or is unavailable. */
+  fallback?: { model: string; thinking: string };
 }
 
 export interface QuickFixDeps {
@@ -260,6 +263,17 @@ export class QuickFixQueue {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
+      // A model that is out of usage hands the job to the fallback the settings name.
+      const attemptOrFallback = async (model: string | undefined, thinking: string) => {
+        const { result: outcome, switchedFrom } = await withFallback(model, thinking, profile.fallback, attempt);
+        if (switchedFrom && profile.fallback) {
+          job.model = profile.fallback.model;
+          job.thinking = profile.fallback.thinking;
+          this.addStep(job, `${switchedFrom} is out of usage or unavailable; ran on ${profile.fallback.model} (${profile.fallback.thinking})`, Date.now());
+          this.changed();
+        }
+        return outcome;
+      };
       let result;
       if (route) {
         job.route = routeLabel(route);
@@ -267,7 +281,7 @@ export class QuickFixQueue {
         job.thinking = route.thinking;
         if (route.model) job.model = route.model;
         this.changed();
-        result = await attempt(route.model, route.thinking);
+        result = await attemptOrFallback(route.model, route.thinking);
         if (fellShort(result) && !controller.signal.aborted) {
           // The routed attempt counts in the metrics on its own; the job re-runs on the configured profile.
           appendMetrics(this.deps.root, this.deps.configDir, [{ ...quickFixMetric({ ...job, status: result.status, finishedAt: Date.now(), usage: result.usage, ...(result.model ? { model: result.model } : {}) }), id: `${job.id}-routed-${job.startedAt}` }]);
@@ -276,10 +290,10 @@ export class QuickFixQueue {
           delete job.routedFrom;
           job.thinking = profile.thinking;
           if (profile.model) job.model = profile.model;
-          result = await attempt(profile.model, profile.thinking);
+          result = await attemptOrFallback(profile.model, profile.thinking);
         }
       } else {
-        result = await attempt(profile.model, profile.thinking);
+        result = await attemptOrFallback(profile.model, profile.thinking);
       }
       job.status = result.status;
       job.report = result.output.trim() || undefined;

package/src/lobby/runtime.ts

@@ -20,8 +20,7 @@ import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listA
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
 import { appendMetrics, readClassifierMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
-import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, persistedRuns, setMinimized, setWidgetSuppressor, ZenScene, zenSnapshot } from "../pi/ui.ts";
-import { panelLines } from "../pi/zen.ts";
+import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, setMinimized, taskSnapshot } from "../pi/ui.ts";
 import { shortTitle } from "../text.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { modelRef, resolveLobbyProfile, resolvePanelProfile } from "../pi/model-support.ts";
@@ -36,14 +35,14 @@ import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, askUser, questionnaires, type Asker } from "./ask.ts";
-import { QuickFixQueue } from "./quickfix.ts";
+import { jobTitle, QuickFixQueue } from "./quickfix.ts";
+import { miniLine, type MiniInput } from "./mini.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
 import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
 import { lobbyTheme } from "./theme.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
 import { openEntrySettings, openSettings } from "../pi/settings-ui.ts";
-import { budgetClock } from "../state/budget.ts";
 
 export const ANCHOR_KEY = "bot-lobby-anchor";
 export { deliverComments };
@@ -59,7 +58,6 @@ interface Runtime {
   visible: boolean;
   /** Stepped aside while pi shows a dialog. */
   asideForPrompt: boolean;
-  scene: ZenScene;
   quickfix: QuickFixQueue;
   planner?: PlanningSession;
   issues: IssuesState;
@@ -97,18 +95,39 @@ let frameTimer: ReturnType<typeof setTimeout> | undefined;
  * through pi.
  */
 function rerender(): void {
-  if (!runtime?.visible || frameTimer) return;
+  // Hidden, only the one-line status under the editor changes.
+  if (!runtime || (!runtime.visible && !miniShown(runtime)) || frameTimer) return;
   const wait = lastFrame + FRAME_MS - Date.now();
   const paint = () => {
     frameTimer = undefined;
     lastFrame = Date.now();
-    if (runtime?.visible) runtime.tui?.requestRender();
+    if (runtime?.visible || (runtime && miniShown(runtime))) runtime.tui?.requestRender();
   };
   if (wait <= 0) return paint();
   frameTimer = setTimeout(paint, wait);
   frameTimer.unref?.();
 }
 
+/** The status line shows under the editor while the lobby is hidden (not while bot-lobby is minimized), unless settings turn it off. */
+function miniShown(state: Runtime): boolean {
+  return !state.visible && !isMinimized() && loadConfig().lobby.miniLine;
+}
+
+/** What the status line shows: the task, the planning round, the quick fix in hand. */
+function miniInput(state: Runtime): MiniInput {
+  const snapshot = taskSnapshot();
+  const planner = state.planner;
+  const job = state.quickfix.running ?? state.quickfix.jobs.find((entry) => entry.status === "queued");
+  const queued = state.quickfix.jobs.filter((entry) => entry.status === "queued" && entry !== job).length;
+  return {
+    ...(snapshot.task ? { task: snapshot.task } : {}),
+    runs: snapshot.runs,
+    ...(planner ? { planning: { busy: planner.busy, round: planner.turns, limit: loadConfig().lobby.maxPlanningRounds, questions: planner.awaitingAnswers ? planner.questions.length : 0, ready: planner.reply?.status === "ready", saved: Boolean(planner.saved) } } : {}),
+    ...(job ? { quickfix: { title: jobTitle(job), running: job.status === "running", queued } } : {}),
+    key: "Alt+L",
+  };
+}
+
 function sessionModel(ctx: ExtensionContext): string | undefined {
   return ctx.model ? modelRef(ctx.model) : undefined;
 }
@@ -426,13 +445,6 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   return `deleted ${taskId} for good`;
 }
 
-/** A task's status box without animations, for a session other than this window's. */
-function taskScene(state: Runtime, task: Task, width: number, height: number): string[] {
-  const now = Date.now();
-  const time = budgetClock(state.root, state.configDir, task.id, now);
-  return panelLines(task, persistedRuns(task), now, false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme, ...(time ? { time } : {}) });
-}
-
 function seatProfile(state: Runtime, member: PanelMember) {
   return resolvePanelProfile(loadConfig(), member, {
     lookup: modelLookup(state.ctx),
@@ -518,15 +530,9 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     theme: () => lobbyTheme(state.ctx.ui.theme),
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
-      const snapshot = zenSnapshot();
+      const snapshot = taskSnapshot();
       return { ...(snapshot.task ? { task: snapshot.task } : {}), runs: snapshot.runs };
     },
-    // The scene's height budget is 3/4 of the rows it is given.
-    scene: (width, height, animated) => state.scene.lines(width, Math.floor(height / 0.75), state.ctx.ui.theme, Date.now(), !animated),
-    advanceScene: (now) => {
-      state.scene.advance(now);
-      return state.scene.delay(now);
-    },
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
     tasks: () => peekTasks(state.root, state.configDir),
@@ -577,7 +583,6 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     sessionChat: (sessionId) => chats.chat(sessionId),
     hasOlderChat: (sessionId) => chats.hasOlder(sessionId),
     chatHistory: (sessionId) => chatHistory(state, sessionId),
-    taskScene: (task, width, height) => taskScene(state, task, width, height),
     requestRender: () => tui.requestRender(),
   };
 }
@@ -716,7 +721,6 @@ function shutdown(): void {
   state.planner?.cancel();
   state.view?.dispose();
   state.handle?.hide();
-  setWidgetSuppressor(() => false);
   onRunUpdates(undefined);
   onMinimizeChange(undefined);
 }
@@ -755,7 +759,6 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     asking: false,
     mouse: false,
     inSettings: false,
-    scene: new ZenScene(),
     quickfix: undefined as unknown as QuickFixQueue,
     issues: new IssuesState(execCommand, ctx.cwd, rerender),
   };
@@ -781,7 +784,6 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.
   lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY));
   state.unsubscribeFeed = lobbyFeed.onChange(rerender);
-  setWidgetSuppressor(() => runtime?.visible === true);
   onRunUpdates((runs) => lobbyFeed.runs(runs));
   onMinimizeChange((value) => {
     if (value) hideLobby();
@@ -789,7 +791,8 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   // Capture pi's TUI through a zero-line widget below the editor.
   ctx.ui.setWidget(ANCHOR_KEY, (tui) => {
     state.tui = tui;
-    return { render: () => [], invalidate: () => {} };
+    // Zero lines while the lobby is up (or bot-lobby is minimized); one status line when it is hidden.
+    return { render: (width: number) => (miniShown(state) ? [miniLine(miniInput(state), width, lobbyTheme(state.ctx.ui.theme))] : []), invalidate: () => {} };
   }, { placement: "belowEditor" });
   // The owner's clock (pi/owner.ts) delivers comments and messages and drives auto mode; the lobby logs what it did.
   onOwnerEvent((event) => {

package/src/lobby/tabs/home.ts

@@ -1,9 +1,8 @@
 /**
- * The Lobby tab: the zen scene of this session's task on top (the oracle
- * and agent animations, or just their status when animations are off), then the
+ * The Lobby tab: the status of this session's task on top, then the
  * conversation with the oracle (text only, no tool rows, no thinking), the
  * activity log of plain-words steps from every agent, and the one place where
- * thoughts show up. Pure: the scene arrives as a callback, the clock as `now`.
+ * thoughts show up. Pure: the clock arrives as `now`.
  */
 import { textWidth } from "../../width.ts";
 import type { Task } from "../../schemas/task.ts";
@@ -18,8 +17,6 @@ export type HomePane = (typeof HOME_PANES)[number];
 
 export interface HomeInput {
   task?: Task;
-  /** Draws the zen scene into at most `height` lines, animated or still; absent when no task is active. */
-  scene?: (width: number, height: number, animated: boolean) => string[];
   chat: readonly ChatEntry[];
   /** The oracle's reply while it streams. */
   liveReply?: string;
@@ -48,8 +45,6 @@ export interface HomeInput {
   keys?: Record<LobbyPanel, string>;
   /** Another session is shown: its name titles the conversation. */
   title?: string;
-  /** The scene is another session's still status (no animations to toggle). */
-  stillScene?: boolean;
   /** What the empty conversation says instead of the default (a session starting, say). */
   emptyNote?: string;
   /** What the empty activity log says instead of "No activity yet.". */
@@ -60,11 +55,6 @@ export interface HomeInput {
 
 /** Wide terminals put the conversation and the activity log side by side. */
 export const HOME_COLUMNS_MIN = 100;
-/** Most lines the scene may take, and its share of the body; the still status needs far fewer. */
-const SCENE_SHARE = 0.45;
-const MAX_SCENE = 36;
-const MAX_STILL = 10;
-
 const SOURCE_COLORS: Record<string, LobbyColor> = {
   MASTER: "accent",
   DEV: "success",
@@ -490,31 +480,6 @@ function thinkingContent(input: HomeInput, thoughts: readonly ThoughtEntry[], wi
   return whole([paint(theme, "dim", input.query ? `No thought matches "${input.query}".` : "Thoughts from the oracle and every agent appear here, and only here.")]);
 }
 
-/**
- * The scene: with animations off (the `animations` panel, off by default)
- * only the task's status box, what the agents are doing and the checklist;
- * with them on, the animated oracle and agents too. Its first line names the
- * key that toggles the animations.
- */
-function sceneLines(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
-  if (!input.task || !input.scene) return [];
-  const animated = input.panels.animations && !input.stillScene;
-  const budget = Math.min(animated ? MAX_SCENE : MAX_STILL, Math.floor(height * SCENE_SHARE));
-  if (budget < (animated ? 6 : 4)) return [];
-  const lines = input.scene(width, budget, animated).slice(0, budget);
-  const note = input.keys && !input.stillScene ? `${input.keys.animations} ${animated ? "hides" : "shows"} animations` : undefined;
-  return keyNote(lines, width, note, theme);
-}
-
-/** `note` at the right end of the first line, dimmed, when it fits beside what is there. */
-function keyNote(lines: readonly string[], width: number, note: string | undefined, theme?: LobbyTheme): string[] {
-  const first = lines[0];
-  if (!note || first === undefined) return [...lines];
-  const gap = width - textWidth(first) - textWidth(note) - 1;
-  if (gap < 2) return [...lines];
-  return [`${first}${" ".repeat(gap)}${paint(theme, "dim", note)}`, ...lines.slice(1)];
-}
-
 function hiddenHint(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
   const keys = input.keys;
   const text = keys
@@ -536,12 +501,11 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   if (height <= 0) return [];
   const { panels } = input;
   const feed = filterFeed(input);
-  const scene = sceneLines(input, width, height, theme);
-  const rest = height - scene.length;
+  const rest = height;
   const showMain = panels.conversation || panels.activity;
   const thinkHeight = !panels.thinking ? 0 : !showMain ? rest : rest >= 18 ? Math.max(5, Math.floor(rest * 0.25)) : rest >= 10 ? 4 : 0;
   const main = rest - thinkHeight;
-  if (!showMain && !panels.thinking) return fill([...scene, ...hiddenHint(input, width, rest, theme)], height, width);
+  if (!showMain && !panels.thinking) return fill(hiddenHint(input, width, rest, theme), height, width);
   const matches = (count: number) => `${count} match${count === 1 ? "" : "es"}`;
   /**
    * One scrollable pane: only the lines it shows are drawn — its newest, or
@@ -563,7 +527,7 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   const thought = currentThought(feed.thoughts);
   const thinkingNote = thought ? `${thought.source} · ${thought.live ? "thinking" : since(input.now - thought.at)}` : input.keys?.thinking;
   const thinkingBox = pane("thinking", "Thinking", thinkingNote, (inner, need, anchor) => thinkingContent(input, feed.thoughts, inner, need, anchor, theme));
-  const top = scene.length;
+  const top = 0;
   let body: string[] = [];
   if (main > 0 && panels.conversation && panels.activity) {
     if (width >= HOME_COLUMNS_MIN) {
@@ -576,5 +540,5 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   } else if (main > 0 && panels.conversation) body = chatBox(top, 0, width, main);
   else if (main > 0 && panels.activity) body = activityBox(top, 0, width, main);
   const think = thinkHeight >= 3 ? thinkingBox(top + main, 0, width, thinkHeight) : [];
-  return fill([...scene, ...fill(body, main), ...think], height, width);
+  return fill([...fill(body, main), ...think], height, width);
 }

package/src/lobby/tabs/tasks.ts

@@ -7,7 +7,7 @@
 import { TERMINAL_STATES, taskRequest, type Task } from "../../schemas/task.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
 import type { PlanComment } from "../../state/comments.ts";
-import { planChecklist } from "../../pi/zen.ts";
+import { planChecklist } from "../../pi/plan-checklist.ts";
 import { persistedRuns } from "../../pi/ui.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";