@a-t-h-i/bot-lobby 0.6.13 → 0.6.15

package/src/lobby/view.ts

@@ -1,3018 +0,0 @@
-/**
- * The lobby: a full-screen, tabbed view over everything bot-lobby does. A tab
- * bar on top, the active tab's body, a search bar while one is in force, a
- * prompt at the bottom whose target follows the tab (the oracle, a plan
- * comment, the planner, a comment on one draft line, a quick fix) and a
- * key-hint line. Two modes, like a modal editor: typing mode sends keys to the
- * prompt; browsing mode (esc) moves through lists and runs the tab's
- * single-key commands. The shortcuts in `keys.ts` (hide, help, search, tabs,
- * pane toggles, paging) work in both. Everything bot-lobby-specific arrives
- * through `LobbyHost`, so the view renders and reacts the same in tests.
- */
-import { decodeKittyPrintable, Editor, Input, Key, matchesKey, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import { textWidth } from "../width.ts";
-import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
-import type { AgentRun } from "../schemas/findings.ts";
-import type { PlannedTask } from "../state/backlog.ts";
-import type { PlanComment } from "../state/comments.ts";
-import { aggregateMetrics, collectMetrics, SORT_KEYS, sortGroups, summarizeClassifier, taskStats, taskTimesByModel, type GroupBy, type MetricRecord, type SortKey } from "../state/metrics.ts";
-import { PANEL_MEMBERS, type BotLobbyConfig, type LobbyAgentKind, type LobbyPanel, type PanelMember } from "../schemas/configuration.ts";
-import type { ChatEntry, LobbyFeed } from "./feed.ts";
-import type { BackgroundSession } from "./sessions.ts";
-import type { QuickFixQueue } from "./quickfix.ts";
-import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } from "./planner.ts";
-import { issueText, type IssuesState } from "./issues.ts";
-import { agentsIndicator, workingAgents } from "./mini.ts";
-import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, tabJumpKey, type KeyMap, type LobbyAction } from "./keys.ts";
-import { beside, BRANCH_GLYPH, bold, box, fit, highlight, pageStep, pagerButton, paint, rule, selectRow, spinner, spread, windowStart, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
-import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
-import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
-import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
-import { filterJobs, newestFirst, renderQuickFix } from "./tabs/quickfix.ts";
-import { renderIssues } from "./tabs/issues.ts";
-import { renderGit } from "./tabs/git.ts";
-import { renderKnowledge, type KnowledgeLayout } from "./tabs/knowledge.ts";
-import { renderExcalidraw, type SessionCheck } from "./tabs/excalidraw.ts";
-import { EXCALIDRAW_AGENTS, MAX_SESSIONS, type ExcalidrawBook, type ExcalidrawSession } from "../excalidraw/sessions.ts";
-import type { EntryRef, KnowledgeBook, KnowledgeFileInfo, KnowledgeView } from "./knowledge.ts";
-import type { PullsState } from "./pulls.ts";
-import type { PullReviews } from "./pr-review.ts";
-import type { WorkspaceInfo } from "../execution/workspace.ts";
-import { filterRecords, renderMetrics } from "./tabs/metrics.ts";
-
-/** The mark before a branch name in the title (shared with the task details). */
-export { BRANCH_GLYPH };
-
-export { TAB_IDS, TAB_LABELS, visibleTabs } from "./prompts.ts";
-export type { TabId } from "./prompts.ts";
-// Local bindings for the uses below; the definitions live in prompts.ts.
-import { TAB_LABELS, visibleTabs, type TabId } from "./prompts.ts";
-
-/** Tabs where the prompt is the point: they open in typing mode and typing in browsing mode resumes it. */
-const PROMPT_FIRST: ReadonlySet<TabId> = new Set(["lobby", "plan", "quickfix"]);
-
-export type LobbyMode = "type" | "browse";
-
-/** What each pane toggle is called in notices and help. */
-const PANEL_NAMES: Record<LobbyPanel, string> = { conversation: "conversation", activity: "activity log", thinking: "thinking" };
-const PANEL_ACTIONS: Record<LobbyPanel, LobbyAction> = { conversation: "toggleConversation", activity: "toggleActivity", thinking: "toggleThinking" };
-
-/**
- * Which session the Lobby tab shows and talks to: this window, one it started
- * in the background, one running in another terminal, or a task whose
- * session is not running at all.
- */
-export type SessionView =
-  | { kind: "here" }
-  | { kind: "background"; key: string }
-  | { kind: "other"; sessionId: string }
-  | { kind: "idle"; taskId: string };
-
-export type SessionWhere = "this window" | "background" | "other terminal" | "not running";
-
-/** One row of the session browser. */
-export interface SessionEntry {
-  view: SessionView;
-  name: string;
-  where: SessionWhere;
-  task?: Task;
-  /** What it is doing: working, idle, starting, ended, or its task's state. */
-  status: string;
-  auto: boolean;
-  /** Questions it waits on you for. */
-  waiting: number;
-  /** The pi session it is (absent for a task no session ever owned). */
-  sessionId?: string;
-  /** The process running it, for sessions in other terminals. */
-  pid?: number;
-}
-
-/** A session running in this project, as its heartbeat tells (see state/presence.ts). */
-export interface LiveSession {
-  sessionId: string;
-  pid: number;
-  name?: string;
-  taskId?: string;
-  mode: string;
-}
-
-/** What `switchTo` needs: the session to run in this window, and the background process to stop first. */
-export interface SwitchTarget {
-  name: string;
-  sessionId?: string;
-  background?: BackgroundSession;
-  /** A task no session owns: this window claims it instead. */
-  claimTaskId?: string;
-}
-
-/** Two views show the same session. */
-function sameView(a: SessionView, b: SessionView): boolean {
-  if (a.kind !== b.kind) return false;
-  if (a.kind === "background" && b.kind === "background") return a.key === b.key;
-  if (a.kind === "other" && b.kind === "other") return a.sessionId === b.sessionId;
-  if (a.kind === "idle" && b.kind === "idle") return a.taskId === b.taskId;
-  return true;
-}
-
-/** Tops a conversation whose earlier messages are not in memory. */
-export const OLDER_NOTE = "↑ earlier messages load as you scroll up";
-
-const SECTION_OF: Record<SessionWhere, string> = { "this window": "THIS WINDOW", background: "BACKGROUND", "other terminal": "OTHER TERMINALS", "not running": "NOT RUNNING" };
-const WHERE_MARKS: Record<SessionWhere, string> = { "this window": "●", background: "◆", "other terminal": "◇", "not running": "○" };
-
-/** One model Pi offers, for the settings page's picker: `provider/id`, its label and thinking levels. */
-export interface ModelChoice {
-  id: string;
-  label: string;
-  thinkingLevels: string[];
-}
-
-/** Everything the view needs from pi and bot-lobby. */
-export interface LobbyHost {
-  rows(): number;
-  theme(): LobbyTheme;
-  sessionId(): string | undefined;
-  /** This session's active task and its runs, as the lobby reads them. */
-  zen(): { task?: Task; runs: readonly AgentRun[] };
-  feed: LobbyFeed;
-  masterBusy(): boolean;
-  tasks(): Task[];
-  plans(): PlannedTask[];
-  comments(taskId: string): PlanComment[];
-  metrics(): MetricRecord[];
-  /** Classifier calls (kind `classifier`), kept out of the agent tables. */
-  classifierMetrics?(): MetricRecord[];
-  /** Send text to the oracle, or start a task when none is active; returns a notice. */
-  toOracle(text: string): string | undefined;
-  comment(taskId: string, text: string): string;
-  startPlanned(plan: PlannedTask): string;
-  discardPlan(id: string): void;
-  abortMaster(): void;
-  hide(): void;
-  quickfix: QuickFixQueue;
-  planner(): PlanningSession | undefined;
-  /** Start a planning session (replacing any other) with these seats on the panel. */
-  newPlanner(seed?: PlannerSeed, seats?: readonly PanelMember[]): PlanningSession;
-  /** The oracle puts the panel's open questions to the user, one questionnaire at a time; returns a notice. */
-  answerPanel(): Promise<string>;
-  /** Save the plan as a pending task, offering to split a long one into several first; returns a notice. */
-  savePlan(): Promise<string>;
-  /** The seats a new session starts with, from settings. */
-  defaultPanel(): readonly PanelMember[];
-  /** Planning rounds before the oracle finalizes alone (`lobby.maxPlanningRounds`); 0 = unlimited. */
-  planningRounds?(): number;
-  /** `model · thinking` a panel seat runs on. */
-  seatLabel(member: PanelMember): string;
-  issues: IssuesState;
-  /** The Git tab's pull requests, read through `gh`. */
-  pulls: PullsState;
-  /** Reviews of pull requests by an agent, and Jev's reads of them. */
-  reviews: PullReviews;
-  /** Every agent's knowledge files: read, edited, commented on. */
-  knowledge: KnowledgeBook;
-  /** The shared Excalidraw sessions (five at most) and which agents each is assigned to. */
-  excalidraw: ExcalidrawBook;
-  /** Join a session's room for a moment and report what is there. */
-  checkExcalidraw(session: ExcalidrawSession): Promise<SessionCheck>;
-  /** Edit a text in pi's multi-line editor (the lobby steps aside meanwhile); the new text, or undefined when cancelled. */
-  editText(title: string, text: string): Promise<string | undefined>;
-  /** The effective config, never a secret; the web settings page reads it. */
-  config?(): BotLobbyConfig;
-  /** Save a whole config, the way the settings menu does; the web settings page writes it. */
-  saveConfig?(config: BotLobbyConfig): void;
-  /** Reload cached config (keys, panes) after a settings change. */
-  configChanged?(): void;
-  /** The models Pi offers, for the settings page's picker. */
-  models?(): ModelChoice[];
-  /** The Issues tab is switched on (`lobby.issues`). */
-  issuesEnabled(): boolean;
-  /** Which panes show (`lobby.panels`), and remembering a change. */
-  panels(): Record<LobbyPanel, boolean>;
-  savePanels(panels: Record<LobbyPanel, boolean>): void;
-  /** Key overrides from the config (`lobby.keys`). */
-  keys(): Readonly<Record<string, string>>;
-  /** Open bot-lobby's settings (or one agent's entry); the lobby steps aside and rereads the config after. */
-  openSettings(entry?: "quickfix" | "planner"): Promise<void>;
-  /** This window's pi session name, when it has one. */
-  sessionName(): string | undefined;
-  /** Background sessions this window started, oldest first. */
-  sessions(): readonly BackgroundSession[];
-  /** Start a task in a new background session, named after the task; the session, or why not. */
-  startSession(start: { request?: string; plan?: PlannedTask; auto?: boolean }): BackgroundSession | string;
-  /** Put the oldest question a background session waits on to the user in this window. */
-  answerDialog(session: BackgroundSession): Promise<void>;
-  /** Auto mode for any task, whichever session drives it. */
-  isAuto(taskId: string): boolean;
-  setAuto(taskId: string, on: boolean): void;
-  /** Leave a message for a task's oracle, delivered by whichever session drives it (now or once one resumes it); returns a notice. */
-  sendToTask(taskId: string, text: string): string;
-  /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
-  sendToSession(sessionId: string, text: string): string;
-  /** Sessions running in this project, other than this window's, from their heartbeats. */
-  liveSessions(): readonly LiveSession[];
-  /** Run another session in this window (stopping its background process first); resolves to a notice. */
-  switchTo(target: SwitchTarget): Promise<string>;
-  /** Archived tasks, most recently archived first. */
-  archivedTasks(): Task[];
-  /** Archive, restore or delete a task; each returns a notice. */
-  archiveTask(taskId: string): string;
-  restoreTask(taskId: string): string;
-  deleteTask(taskId: string, where: "list" | "archive"): string;
-  /** Another session's conversation, read from its saved session file (its newest messages). */
-  sessionChat(sessionId: string): ChatEntry[];
-  /** Whether another session has messages earlier than `sessionChat` returns. */
-  hasOlderChat(sessionId: string): boolean;
-  /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
-  chatHistory(sessionId?: string): readonly ChatEntry[];
-  profileLabel(kind: LobbyAgentKind): string;
-  /** The repository (or folder) and branch the title shows; the folder's name alone until git has answered. */
-  workspace?(): WorkspaceInfo;
-  /** Ask for the workspace to be read again (the branch may have changed); it arrives through `workspace()`. */
-  refreshWorkspace?(): void;
-  requestRender(): void;
-  now?(): number;
-}
-
-/** Live work speeds the clock up so spinners move. */
-export const LIVE_MS = 250;
-export const IDLE_MS = 1000;
-/** How often task and metrics data is reread from disk while the lobby is open. */
-export const DATA_REFRESH_MS = 2000;
-const NOTICE_MS = 6000;
-/** Lines one wheel notch scrolls. */
-const WHEEL_LINES = 3;
-/** The longest repository and branch names the title shows whole. */
-const TITLE_NAME_MAX = 28;
-const TITLE_BRANCH_MAX = 36;
-
-/** The prompt editor, with its target written into the top border. */
-class LobbyEditor extends Editor {
-  label = "";
-  paintLabel: (text: string) => string = (text) => text;
-
-  protected override renderTopBorder(width: number, hiddenLineCount: number): string {
-    if (!this.label) return super.renderTopBorder(width, hiddenLineCount);
-    const label = ` ${this.label} `;
-    const more = hiddenLineCount > 0 ? ` ↑${hiddenLineCount} ` : "";
-    const rest = width - 2 - textWidth(label) - textWidth(more);
-    if (rest < 1) return super.renderTopBorder(width, hiddenLineCount);
-    return `${this.borderColor("──")}${this.paintLabel(label)}${this.borderColor("─".repeat(rest))}${more ? this.borderColor(more) : ""}`;
-  }
-}
-
-/** The editor's reverse-video block cursor. */
-const REVERSE_VIDEO = /\x1b\[7m([^\x1b]*)\x1b\[0m/g;
-
-interface Notice {
-  text: string;
-  at: number;
-  kind: "info" | "warning";
-}
-
-/** A key and what it does, for the help screen. */
-interface KeyHelp {
-  key: string;
-  text: string;
-}
-
-function isPrintable(data: string): string | undefined {
-  const kitty = decodeKittyPrintable(data);
-  if (kitty !== undefined) return kitty;
-  return data.length === 1 && data.charCodeAt(0) >= 32 && data.charCodeAt(0) !== 127 ? data : undefined;
-}
-
-/** A mouse report in SGR encoding (`ESC [ < b ; x ; y M` or `m`), zero-based cells. */
-export interface MouseReport {
-  kind: "press" | "release" | "wheel";
-  button: number;
-  x: number;
-  y: number;
-  /** Wheel direction: -1 up, 1 down. */
-  delta: number;
-}
-
-const SGR_MOUSE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
-
-/** Parse an SGR mouse report, the form terminals send once the lobby turns mouse reporting on. */
-export function parseMouse(data: string): MouseReport | undefined {
-  const match = SGR_MOUSE.exec(data);
-  if (!match) return undefined;
-  const code = Number(match[1]);
-  const x = Number(match[2]) - 1;
-  const y = Number(match[3]) - 1;
-  if (code & 64) return { kind: "wheel", button: code, x, y, delta: (code & 1) === 1 ? 1 : -1 };
-  return { kind: match[4] === "M" ? "press" : "release", button: code & 3, x, y, delta: 0 };
-}
-
-function clip(text: string, max: number): string {
-  const flat = text.replace(/\s+/g, " ").trim();
-  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
-}
-
-export class LobbyView implements Component, Focusable {
-  tab: TabId = "lobby";
-  mode: LobbyMode = "type";
-  private readonly host: LobbyHost;
-  private readonly editor: LobbyEditor;
-  private readonly search: Input;
-  private focusedState = false;
-  private tick = 0;
-  private timer: ReturnType<typeof setTimeout> | undefined;
-  private running = false;
-  private notice: Notice | undefined;
-  private readonly drafts: Partial<Record<TabId, string>> = {};
-  /** Double-press confirmations, such as discarding a plan. */
-  private armed: string | undefined;
-  /** The keys, the panes on show and whether Issues is on, read once from the config. */
-  private keys: KeyMap;
-  private panels: Record<LobbyPanel, boolean>;
-  private issuesOn: boolean;
-  /** The help screen covers the body. */
-  help = false;
-  /** The session switcher covers the body. */
-  picking = false;
-  private pickIndex = 0;
-  /** The session the Lobby tab shows and talks to. */
-  viewing: SessionView = { kind: "here" };
-  /** The Lobby prompt starts a task in a new session instead of talking to an oracle. */
-  newSession = false;
-  /** The search bar has the keys. */
-  searching = false;
-  /** Each tab's search, kept while you move between tabs. */
-  private readonly queries: Partial<Record<TabId, string>> = {};
-  /** Where the body starts and where each tab's label sits in the tab bar, for clicks. */
-  private bodyTop = 1;
-  private promptTop = Number.POSITIVE_INFINITY;
-  private tabSpans: Array<{ tab: TabId; from: number; to: number }> = [];
-
-  /** Each Lobby pane's scroll, in lines back from its newest, and the pane the keys scroll. */
-  private readonly homeOffsets: Record<HomePane, number> = { conversation: 0, activity: 0, thinking: 0 };
-  homeFocus: HomePane = "conversation";
-  /** How many lines each pane held last frame, so a pane scrolled back stays on what you are reading as lines arrive. */
-  private readonly seenTotals = new Map<string, number>();
-  /** Each Lobby pane's newest entry last frame: those panes measure what arrived below it, as their totals are estimates. */
-  private readonly marks = new Map<string, PaneMark>();
-  /** Where the current tab's scrollable panes landed in the last frame. */
-  private readonly panes: PaneLayout = new Map();
-  private tasksSelected = 0;
-  private tasksFocus: "list" | "detail" = "list";
-  private tasksDetailOffset = 0;
-  private commentTarget: string | undefined;
-  private planOffset = 0;
-  private planFocus: "talk" | "draft" = "talk";
-  private planDraftOffset = 0;
-  /** The draft line the cursor is on, and the one a comment is being written for. */
-  planCursor = 0;
-  private lineTarget: string | undefined;
-  private readonly planLayout: PlanLayout = { draftTop: 0, draftLeft: 0, draftWidth: 0, draftRows: 0, draftStart: 0, draftText: [] };
-  /** Seats for the next planning session, until one exists. */
-  private seats: Set<PanelMember> | undefined;
-  private fixSelected = 0;
-  private fixFocus: "list" | "detail" = "list";
-  private fixDetailOffset = 0;
-  private issueSelected = 0;
-  private issueFocus: "list" | "detail" = "list";
-  private issueDetailOffset = 0;
-  private issueDraft = false;
-  private gitSelected = 0;
-  private gitFocus: "list" | "detail" = "list";
-  private gitDetailOffset = 0;
-  /** The prompt is taking what the review of the selected pull request should look at first. */
-  private gitFocusDraft = false;
-  private kSelected = 0;
-  private kFocus: "list" | "detail" = "list";
-  /** The picked entry of the open knowledge file (an index into its entries), and how far its pane is scrolled. */
-  private kCursor = 0;
-  private kOffset = 0;
-  private readonly kLayout: KnowledgeLayout = { offset: 0, total: 0, rows: 0 };
-  /** The prompt is writing an edit of the picked entry, a note on it, or a new entry after it. */
-  private kDraft: { kind: "edit" | "comment" | "add"; entry?: EntryRef } | undefined;
-  private xSelected = 0;
-  private xFocus: "list" | "detail" = "list";
-  /** The agent under the cursor in the picked session's checklist. */
-  private xAgent = 0;
-  /** The prompt is taking a link to add (with an optional name), the name of a new room, or a new name for the picked session. */
-  private xDraft: "add" | "new" | "rename" | undefined;
-  private readonly xChecks = new Map<string, SessionCheck>();
-  private readonly xChecking = new Set<string>();
-  private metricsSelected = 0;
-  private metricsBy: GroupBy = "model";
-  private metricsSort: SortKey = "runs";
-
-  /** The Tasks tab lists archived tasks too (v). */
-  showArchived = false;
-  private data: { tasks: Task[]; plans: PlannedTask[]; archived: Task[]; comments: Map<string, PlanComment[]>; metrics: MetricRecord[]; classifierMetrics: MetricRecord[]; knowledge: { files: KnowledgeFileInfo[]; view?: KnowledgeView }; excalidraw: ExcalidrawSession[]; at: number } = {
-    tasks: [],
-    plans: [],
-    archived: [],
-    comments: new Map(),
-    metrics: [],
-    classifierMetrics: [],
-    knowledge: { files: [] },
-    excalidraw: [],
-    at: 0,
-  };
-
-  constructor(tui: TUI, host: LobbyHost, editorTheme: EditorTheme) {
-    this.host = host;
-    this.editor = new LobbyEditor(tui, editorTheme, { paddingX: 1 });
-    this.editor.onSubmit = (text) => this.submit(text);
-    this.search = new Input({ prompt: "", placeholder: "type to search this tab" });
-    this.keys = keyMap(host.keys());
-    this.panels = { ...host.panels() };
-    this.issuesOn = host.issuesEnabled();
-  }
-
-  get focused(): boolean {
-    return this.focusedState;
-  }
-
-  set focused(value: boolean) {
-    this.focusedState = value;
-    this.syncFocus();
-  }
-
-  private syncFocus(): void {
-    this.editor.focused = this.focusedState && this.mode === "type" && !this.searching;
-    this.search.focused = this.focusedState && this.searching;
-  }
-
-  private now(): number {
-    return this.host.now?.() ?? Date.now();
-  }
-
-  /** Start the lobby clock (while visible). */
-  start(): void {
-    if (this.running) return;
-    this.running = true;
-    this.refreshData(true);
-    this.schedule(0);
-  }
-
-  stop(): void {
-    this.running = false;
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = undefined;
-  }
-
-  dispose(): void {
-    this.stop();
-  }
-
-  private schedule(delay: number): void {
-    if (this.timer) clearTimeout(this.timer);
-    if (!this.running) return;
-    this.timer = setTimeout(() => this.step(), delay);
-    this.timer.unref?.();
-  }
-
-  private isLive(): boolean {
-    const zen = this.host.zen();
-    return this.host.masterBusy()
-      || Boolean(this.host.quickfix.running)
-      || Boolean(this.host.planner()?.busy)
-      || this.host.sessions().some((session) => session.busy)
-      || (this.issuesOn && this.host.issues.loading)
-      || (this.tab === "git" && this.host.pulls.loading)
-      || this.host.reviews.busy
-      || zen.runs.some((run) => run.status === "running")
-      || Boolean(zen.task && !zen.task.paused && !TERMINAL_STATES.includes(zen.task.state));
-  }
-
-  /** One clock step: reread data when due, repaint. */
-  private step(): void {
-    if (!this.running) return;
-    this.tick += 1;
-    this.refreshData(false);
-    this.host.requestRender();
-    this.schedule(this.isLive() ? LIVE_MS : IDLE_MS);
-  }
-
-  /** Reread tasks, plans, comments and metrics from disk (throttled unless forced). */
-  refreshData(force: boolean): void {
-    const now = this.now();
-    if (!force && now - this.data.at < DATA_REFRESH_MS) return;
-    this.dataVersion += 1;
-    this.host.refreshWorkspace?.();
-    this.data = {
-      tasks: this.host.tasks(),
-      plans: this.host.plans(),
-      archived: this.showArchived ? this.host.archivedTasks() : [],
-      comments: new Map(),
-      metrics: this.tab === "metrics" ? this.host.metrics() : this.data.metrics,
-      classifierMetrics: this.tab === "metrics" ? this.host.classifierMetrics?.() ?? [] : this.data.classifierMetrics,
-      knowledge: this.tab === "knowledge" ? this.readKnowledge() : this.data.knowledge,
-      excalidraw: this.host.excalidraw.list(),
-      at: now,
-    };
-    if (this.tab === "tasks") {
-      const row = this.taskRowList()[this.tasksSelected];
-      if (row?.kind === "task") this.data.comments.set(row.id, this.host.comments(row.id));
-    }
-  }
-
-  /** Every knowledge file, and the selected one read as entries. */
-  private readKnowledge(): { files: KnowledgeFileInfo[]; view?: KnowledgeView } {
-    const files = this.host.knowledge.files();
-    this.kSelected = Math.max(0, Math.min(this.kSelected, files.length - 1));
-    const info = files[this.kSelected];
-    return { files, ...(info ? { view: this.host.knowledge.open(info.agent, info.file) } : {}) };
-  }
-
-  /** Read the open knowledge file again (after an edit, or another file was picked). */
-  private reloadKnowledge(): void {
-    this.data.knowledge = this.readKnowledge();
-  }
-
-  private say(text: string, kind: Notice["kind"] = "info"): void {
-    this.notice = { text, at: this.now(), kind };
-  }
-
-  /** The search in force on this tab. */
-  query(): string | undefined {
-    return this.queries[this.tab]?.trim() || undefined;
-  }
-
-  /* ---------------------------------------------------------------- tabs */
-
-  tabs(): TabId[] {
-    return visibleTabs(this.issuesOn);
-  }
-
-  /** Open the Quick fix tab on a job the oracle routed there, with a line saying so. */
-  showQuickFix(id: string): void {
-    this.setTab("quickfix");
-    delete this.queries.quickfix;
-    this.fixSelected = Math.max(0, this.fixJobs().findIndex((job) => job.id === id));
-    this.fixDetailOffset = 0;
-    this.say(`${id} — the oracle sent your request to the quick-fix agent`);
-  }
-
-  setTab(tab: TabId): void {
-    if (tab === this.tab) return;
-    if (!this.tabs().includes(tab)) return this.say(`the ${TAB_LABELS[tab]} tab is off — set lobby.${tab} to true in the config to bring it back`, "warning");
-    // An entry being edited is not a draft to come back to: its text was only lent to the prompt.
-    if (this.kDraft || this.xDraft) {
-      this.kDraft = undefined;
-      this.xDraft = undefined;
-      this.editor.setText("");
-    }
-    this.drafts[this.tab] = this.editor.getText();
-    this.tab = tab;
-    this.editor.setText(this.drafts[tab] ?? "");
-    this.commentTarget = undefined;
-    this.lineTarget = undefined;
-    this.issueDraft = false;
-    this.gitFocusDraft = false;
-    this.armed = undefined;
-    this.help = false;
-    this.picking = false;
-    this.newSession = false;
-    this.closeSearch();
-    this.setMode(PROMPT_FIRST.has(tab) ? "type" : "browse");
-    this.refreshData(true);
-    if (tab === "issues" && !this.host.issues.loaded && !this.host.issues.loading) void this.host.issues.refresh().then(() => this.loadIssueDetail());
-    if (tab === "git" && !this.host.pulls.loaded && !this.host.pulls.loading) void this.host.pulls.refresh().then(() => this.loadPullDetail());
-    else if (tab === "git") void this.loadPullDetail();
-    this.host.requestRender();
-  }
-
-  private cycleTab(direction: 1 | -1): void {
-    const tabs = this.tabs();
-    const index = Math.max(0, tabs.indexOf(this.tab));
-    this.setTab(tabs[(index + direction + tabs.length) % tabs.length]!);
-  }
-
-  private setMode(mode: LobbyMode): void {
-    this.mode = this.tab === "metrics" ? "browse" : mode;
-    this.syncFocus();
-  }
-
-  /** Open the prompt for a comment on `taskId`'s plan (from any tab). */
-  commentOn(taskId: string): void {
-    this.setTab("tasks");
-    delete this.queries.tasks;
-    const rows = this.taskRowList();
-    const index = rows.findIndex((row) => row.id === taskId);
-    if (index >= 0) this.tasksSelected = index;
-    this.refreshData(true);
-    this.commentTarget = taskId;
-    this.setMode("type");
-  }
-
-  /** Plan an issue: seed a planning session with it and switch to the Plan tab. */
-  async planIssue(number: number): Promise<void> {
-    const detail = await this.host.issues.detail(number);
-    if (!detail) return this.say(`could not load issue #${number}`, "warning");
-    const session = this.host.newPlanner({ issue: { number: detail.number, title: detail.title, ...(detail.url ? { url: detail.url } : {}) }, body: issueText(detail) }, [...this.seatSet()]);
-    this.resetPlanScroll();
-    this.setTab("plan");
-    void session.open();
-  }
-
-  /** Show or hide one pane and remember it in the config. */
-  togglePanel(panel: LobbyPanel): void {
-    const shown = !this.panels[panel];
-    this.panels = { ...this.panels, [panel]: shown };
-    this.host.savePanels(this.panels);
-    const key = keyLabel(this.keys[PANEL_ACTIONS[panel]]);
-    const where = this.tab === "lobby" ? "" : " on the Lobby tab";
-    this.say(`${PANEL_NAMES[panel]} ${shown ? "shown" : "hidden"}${where} · ${key} ${shown ? "hides" : "shows"} it`);
-  }
-
-  panelShown(panel: LobbyPanel): boolean {
-    return this.panels[panel];
-  }
-
-  /** Reread keys, panes and the Issues switch, after the settings changed them. */
-  reloadConfig(): void {
-    this.keys = keyMap(this.host.keys());
-    this.panels = { ...this.host.panels() };
-    this.issuesOn = this.host.issuesEnabled();
-    if (!this.tabs().includes(this.tab)) this.setTab("lobby");
-  }
-
-  private openSettings(entry?: "quickfix" | "planner"): void {
-    void this.host.openSettings(entry).then(() => this.host.requestRender());
-  }
-
-  /* -------------------------------------------------------------- search */
-
-  private openSearch(): void {
-    this.help = false;
-    this.searching = true;
-    this.search.setValue(this.queries[this.tab] ?? "");
-    this.syncFocus();
-  }
-
-  /** Close the search bar; the query stays in force unless `clear`. */
-  private closeSearch(clear = false): void {
-    if (clear) delete this.queries[this.tab];
-    this.searching = false;
-    this.syncFocus();
-  }
-
-  private searchKey(data: string): void {
-    if (matchesKey(data, Key.escape)) {
-      const had = Boolean(this.query());
-      this.closeSearch(true);
-      if (had) this.say("search cleared");
-      return;
-    }
-    if (matchesKey(data, Key.enter)) {
-      if (!this.query()) delete this.queries[this.tab];
-      return this.closeSearch();
-    }
-    if (matchesKey(data, Key.up) || matchesKey(data, Key.down)) {
-      // Keep the query, let the arrows move through what it found.
-      this.closeSearch();
-      return this.scroll(matchesKey(data, Key.up) ? -1 : 1);
-    }
-    this.search.handleInput(data);
-    const value = this.search.getValue();
-    if (value) this.queries[this.tab] = value;
-    else delete this.queries[this.tab];
-    this.resetSelections();
-  }
-
-  /** A new search starts every list at its top. */
-  private resetSelections(): void {
-    for (const pane of HOME_PANES) this.homeOffsets[pane] = 0;
-    this.planOffset = 0;
-    switch (this.tab) {
-      case "tasks":
-        this.tasksSelected = 0;
-        this.tasksDetailOffset = 0;
-        return;
-      case "quickfix":
-        this.fixSelected = 0;
-        this.fixDetailOffset = 0;
-        return;
-      case "metrics":
-        this.metricsSelected = 0;
-        return;
-      default:
-        return;
-    }
-  }
-
-  /* --------------------------------------------------------------- input */
-
-  handleInput(data: string): void {
-    this.handleKey(data);
-    this.host.requestRender();
-  }
-
-  private handleKey(data: string): void {
-    const mouse = parseMouse(data);
-    if (mouse) return this.mouseReport(mouse);
-    const action = actionFor(data, this.keys);
-    if (this.help) {
-      this.help = false;
-      // Esc, ?, q and the help key only close it; anything else also does its job.
-      if (action === "help" || matchesKey(data, Key.escape) || data === "?" || data === "q" || matchesKey(data, Key.enter)) return;
-    }
-    // The session switcher takes the keys while it is open (shortcuts other than its own still work).
-    if (this.picking && (!action || action === "sessions" || action === "newSession") && this.pickerKey(data, action)) return;
-    // While searching, the shortcuts still work; everything else edits the query.
-    if (this.searching) return action ? this.runAction(action) : this.searchKey(data);
-    if (action) return this.runAction(action);
-    const tabs = this.tabs();
-    for (const [index, tab] of tabs.entries()) {
-      if (matchesKey(data, tabJumpKey(index))) return this.setTab(tab);
-    }
-    if (matchesKey(data, Key.ctrl("c"))) {
-      if (this.editor.getText()) return this.editor.setText("");
-      return this.host.hide();
-    }
-    if (this.mode === "type") return this.typeKey(data);
-    return this.browseKey(data);
-  }
-
-  private runAction(action: LobbyAction): void {
-    switch (action) {
-      case "hide":
-        return this.host.hide();
-      case "help":
-        this.help = !this.help;
-        return;
-      case "settings":
-        return this.openSettings();
-      case "savePlan":
-        return this.savePlan();
-      case "sessions":
-        return this.picking ? void (this.picking = false) : this.openPicker();
-      case "newSession":
-        return this.startNewSessionPrompt();
-      case "toggleAuto":
-        return this.toggleAuto();
-      case "search":
-        return this.searching ? this.closeSearch() : this.openSearch();
-      case "nextTab":
-        return this.cycleTab(1);
-      case "prevTab":
-        return this.cycleTab(-1);
-      case "toggleConversation":
-        return this.togglePanel("conversation");
-      case "toggleActivity":
-        return this.togglePanel("activity");
-      case "toggleThinking":
-        return this.togglePanel("thinking");
-      case "scrollUp":
-        return this.scroll(-this.pageSize());
-      case "scrollDown":
-        return this.scroll(this.pageSize());
-    }
-  }
-
-  private typeKey(data: string): void {
-    if (matchesKey(data, Key.escape)) {
-      if (this.tab === "lobby" && this.host.masterBusy() && !this.editor.getText().trim()) {
-        this.host.abortMaster();
-        return this.say("stopping the oracle…");
-      }
-      this.commentTarget = undefined;
-      this.issueDraft = false;
-      this.gitFocusDraft = false;
-      if (this.kDraft || this.xDraft) {
-        this.kDraft = undefined;
-        this.xDraft = undefined;
-        this.editor.setText("");
-      }
-      this.newSession = false;
-      if (this.lineTarget) {
-        this.lineTarget = undefined;
-        this.planFocus = "draft";
-      }
-      return this.setMode("browse");
-    }
-    this.editor.handleInput(data);
-  }
-
-  private browseKey(data: string): void {
-    if (matchesKey(data, Key.escape) && this.query()) {
-      delete this.queries[this.tab];
-      return this.say("search cleared");
-    }
-    if (data === "/") return this.openSearch();
-    if (data === "?") {
-      this.help = true;
-      return;
-    }
-    if (matchesKey(data, Key.up) || (!PROMPT_FIRST.has(this.tab) && data === "k")) return this.scroll(-1);
-    if (matchesKey(data, Key.down) || (!PROMPT_FIRST.has(this.tab) && data === "j")) return this.scroll(1);
-    if (matchesKey(data, Key.left) || matchesKey(data, Key.right)) return this.movePaneFocus(matchesKey(data, Key.left) ? -1 : 1);
-    if (matchesKey(data, Key.home) || matchesKey(data, Key.end)) return this.scrollToEdge(matchesKey(data, Key.home));
-    const tabs = this.tabs();
-    const digit = /^[1-9]$/.test(data) ? Number(data) - 1 : -1;
-    if (!PROMPT_FIRST.has(this.tab) && digit >= 0 && digit < tabs.length) {
-      // Plain digits jump without Alt; the Alt key stays the shared definition.
-      void tabJumpKey(digit);
-      return this.setTab(tabs[digit]!);
-    }
-    if (data === "i" && this.tab !== "metrics" && this.tab !== "tasks" && this.tab !== "issues" && this.tab !== "git" && this.tab !== "knowledge" && this.tab !== "excalidraw") return this.setMode("type");
-    if (this.tabCommand(data)) return;
-    const printable = isPrintable(data);
-    if (printable && PROMPT_FIRST.has(this.tab)) {
-      this.setMode("type");
-      this.editor.handleInput(data);
-    }
-  }
-
-  /** The pane the keys scroll on this tab. */
-  private focusedPane(): string {
-    switch (this.tab) {
-      case "lobby":
-        return this.homePane();
-      case "plan":
-        return this.planFocus;
-      case "tasks":
-        return this.tasksFocus;
-      case "quickfix":
-        return this.fixFocus;
-      case "issues":
-        return this.issueFocus;
-      case "git":
-        return this.gitFocus;
-      case "knowledge":
-        return this.kFocus;
-      case "excalidraw":
-        return this.xFocus;
-      case "metrics":
-        return "table";
-    }
-  }
-
-  /** The focused Lobby pane, or the first one showing when it is hidden. */
-  private homePane(): HomePane {
-    const shown = this.shownHomePanes();
-    if (!shown.includes(this.homeFocus) && shown.length > 0) this.homeFocus = shown[0]!;
-    return this.homeFocus;
-  }
-
-  private shownHomePanes(): HomePane[] {
-    const drawn = HOME_PANES.filter((pane) => this.tab === "lobby" && this.panes.has(pane));
-    return drawn.length > 0 ? drawn : HOME_PANES.filter((pane) => this.panels[pane]);
-  }
-
-  /** A page of the focused pane: its rows less one, so a line of context carries over. */
-  private pageSize(): number {
-    const pane = this.panes.get(this.focusedPane());
-    return pane && pane.rows > 2 ? pane.rows - 1 : 10;
-  }
-
-  /** ← → move between the tab's panes. */
-  private movePaneFocus(direction: -1 | 1): void {
-    switch (this.tab) {
-      case "lobby": {
-        const shown = this.shownHomePanes();
-        if (shown.length === 0) return;
-        const index = Math.max(0, shown.indexOf(this.homePane()));
-        this.homeFocus = shown[(index + direction + shown.length) % shown.length]!;
-        return;
-      }
-      case "plan":
-        this.planFocus = direction < 0 ? "talk" : "draft";
-        if (this.planFocus === "draft") this.cursorToView();
-        return;
-      case "tasks":
-        this.tasksFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "quickfix":
-        this.fixFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "issues":
-        this.issueFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "git":
-        this.gitFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "knowledge":
-        this.kFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "excalidraw":
-        this.xFocus = direction < 0 ? "list" : "detail";
-        return;
-      case "metrics":
-        return;
-    }
-  }
-
-  /** Arrow keys (±1) and page keys (± a page): scroll or select in the tab's focused pane. */
-  private scroll(delta: number): void {
-    switch (this.tab) {
-      case "lobby":
-        return this.scrollPane(this.homePane(), delta);
-      case "plan":
-        return this.scrollPane(this.planFocus, delta);
-      case "tasks":
-        // Page keys always page the detail; the arrows follow the focus.
-        return this.scrollPane(Math.abs(delta) > 1 ? "detail" : this.tasksFocus, delta);
-      case "quickfix":
-        return this.scrollPane(Math.abs(delta) > 1 ? "detail" : this.fixFocus, delta);
-      case "issues":
-        if (this.issueFocus === "detail" || Math.abs(delta) > 1) this.issueDetailOffset = Math.max(0, this.issueDetailOffset + delta);
-        else {
-          this.issueSelected = Math.max(0, Math.min(this.host.issues.issues.length - 1, this.issueSelected + delta));
-          this.issueDetailOffset = 0;
-          void this.loadIssueDetail();
-        }
-        return;
-      case "git":
-        if (this.gitFocus === "detail" || Math.abs(delta) > 1) this.gitDetailOffset = Math.max(0, this.gitDetailOffset + delta);
-        else {
-          this.gitSelected = Math.max(0, Math.min(this.host.pulls.pulls.length - 1, this.gitSelected + delta));
-          this.gitDetailOffset = 0;
-          void this.loadPullDetail();
-        }
-        return;
-      case "knowledge":
-        return this.moveKnowledge(delta);
-      case "excalidraw":
-        return this.moveExcalidraw(delta);
-      case "metrics":
-        return this.scrollPane("table", delta);
-    }
-  }
-
-  /** Arrows on the Excalidraw tab: pick a session, or (in the checklist) an agent. */
-  private moveExcalidraw(delta: number): void {
-    const step = Math.sign(delta);
-    if (this.xFocus === "list") {
-      const next = Math.max(0, Math.min(this.data.excalidraw.length - 1, this.xSelected + step));
-      if (next !== this.xSelected) this.xAgent = 0;
-      this.xSelected = next;
-      return;
-    }
-    this.xAgent = Math.max(0, Math.min(EXCALIDRAW_AGENTS.length - 1, this.xAgent + step));
-  }
-
-  /** Arrows and pages on the Knowledge tab: pick a file, or pick an entry of the open one (a page moves several). */
-  private moveKnowledge(delta: number): void {
-    const knowledge = this.data.knowledge;
-    if (this.kFocus === "list") {
-      const next = Math.max(0, Math.min(knowledge.files.length - 1, this.kSelected + delta));
-      if (next === this.kSelected) return;
-      this.kSelected = next;
-      this.kCursor = 0;
-      this.kOffset = 0;
-      this.reloadKnowledge();
-      return;
-    }
-    const count = knowledge.view?.entries.length ?? 0;
-    const step = Math.abs(delta) > 1 ? Math.sign(delta) * Math.max(2, Math.round(Math.abs(delta) / 3)) : delta;
-    this.kCursor = Math.max(0, Math.min(count - 1, this.kCursor + step));
-  }
-
-  /**
-   * Scroll one pane of the current tab by `delta` lines, positive toward its
-   * end. Lists move their selection instead; the draft moves its cursor (the
-   * wheel scrolls it and the cursor follows only when it would leave the screen).
-   */
-  private scrollPane(pane: string, delta: number, wheel = false, page = false): void {
-    if (delta === 0) return;
-    switch (pane) {
-      case "conversation":
-      case "activity":
-      case "thinking":
-        this.homeOffsets[pane] = Math.max(0, this.homeOffsets[pane] - delta);
-        break;
-      case "talk":
-        this.planOffset = Math.max(0, this.planOffset - delta);
-        break;
-      case "draft":
-        if (wheel || page) this.wheelDraft(delta);
-        else this.moveCursor(delta);
-        break;
-      case "list":
-        if (this.tab === "tasks") this.selectTask(this.tasksSelected + (page ? delta : Math.sign(delta)));
-        else if (this.tab === "quickfix") {
-          this.fixSelected = Math.max(0, Math.min(this.fixJobs().length - 1, this.fixSelected + (page ? delta : Math.sign(delta))));
-          this.fixDetailOffset = 0;
-        }
-        break;
-      case "detail":
-        if (this.tab === "tasks") this.tasksDetailOffset = Math.max(0, this.tasksDetailOffset + delta);
-        else if (this.tab === "quickfix") this.fixDetailOffset = Math.max(0, this.fixDetailOffset + delta);
-        break;
-      case "table":
-        this.metricsSelected = Math.max(0, this.metricsSelected + (wheel && !page ? Math.sign(delta) : delta));
-        break;
-    }
-    this.clampScroll();
-    if (pane === "conversation") this.followHistory();
-  }
-
-  /** Home and End: the oldest or first line of the focused pane, or back to its newest or last. */
-  private scrollToEdge(start: boolean): void {
-    const pane = this.focusedPane();
-    const far = start ? -1e9 : 1e9;
-    if (pane === "draft") {
-      const last = this.planLayout.draftText.length - 1;
-      this.planCursor = start ? 0 : Math.max(0, last);
-      this.moveCursor(0);
-      return;
-    }
-    if (pane === "list" && this.tab === "tasks") return this.selectTask(start ? 0 : this.taskRowList().length - 1);
-    if (pane === "list" && this.tab === "quickfix") {
-      this.fixSelected = start ? 0 : Math.max(0, this.fixJobs().length - 1);
-      this.fixDetailOffset = 0;
-      return;
-    }
-    if (pane === "table") {
-      this.metricsSelected = start ? 0 : Number.MAX_SAFE_INTEGER;
-      return;
-    }
-    this.scrollPane(pane, far);
-    // Home loads earlier messages at the top; go on to the very first of them.
-    if (start && pane === "conversation" && this.history) this.homeOffsets.conversation = Number.MAX_SAFE_INTEGER;
-  }
-
-  /** The wheel over the draft scrolls it; the cursor follows only when it would leave the screen. */
-  private wheelDraft(delta: number): void {
-    const rows = Math.max(1, this.planLayout.draftRows);
-    const max = Math.max(0, this.planLayout.draftText.length - rows);
-    this.planDraftOffset = Math.max(0, Math.min(max, this.planLayout.draftStart + delta));
-    if (this.planCursor < this.planDraftOffset) this.planCursor = this.planDraftOffset;
-    if (this.planCursor >= this.planDraftOffset + rows) this.planCursor = this.planDraftOffset + rows - 1;
-  }
-
-  /**
-   * Keep every offset within what its pane holds, so scrolling back the other
-   * way responds at once; a pane scrolled back from its newest line stays on
-   * the lines being read as new ones arrive. True when that moved a pane.
-   */
-  private clampScroll(): boolean {
-    let moved = false;
-    const limit = (name: string, offset: number, anchored: boolean): number => {
-      const pane = this.panes.get(name);
-      if (!pane) return offset;
-      const grew = this.grewBelow(name, pane);
-      let next = offset;
-      if (anchored && next > 0 && grew > 0) {
-        next += grew;
-        moved = true;
-      }
-      return Math.min(next, Math.max(0, pane.total - pane.rows));
-    };
-    switch (this.tab) {
-      case "lobby":
-        for (const pane of HOME_PANES) this.homeOffsets[pane] = limit(pane, this.homeOffsets[pane], true);
-        break;
-      case "plan":
-        this.planOffset = limit("talk", this.planOffset, true);
-        break;
-      case "tasks":
-        this.tasksDetailOffset = limit("detail", this.tasksDetailOffset, false);
-        break;
-      case "quickfix":
-        this.fixDetailOffset = limit("detail", this.fixDetailOffset, false);
-        break;
-      default:
-        break;
-    }
-    return moved;
-  }
-
-  /**
-   * Lines that arrived below a pane since it was last looked at, counted once.
-   * A pane that measures them from its newest entry says so; for the others
-   * (their totals exact) the total's growth stands in. An estimated total also
-   * moves as scrolling draws more or fewer of the entries it estimates, and
-   * following that pinned a pane scrolled to its top there.
-   */
-  private grewBelow(name: string, pane: PaneBox): number {
-    const seen = this.seenTotals.get(name);
-    this.seenTotals.set(name, pane.total);
-    const follow = pane.follow;
-    if (!follow) return seen === undefined ? 0 : pane.total - seen;
-    if (follow.mark) this.marks.set(name, follow.mark);
-    else this.marks.delete(name);
-    const grew = follow.grew;
-    follow.grew = 0;
-    return grew;
-  }
-
-  /** Move the draft cursor by `delta` lines, skipping blank ones, and keep it on screen. */
-  private moveCursor(delta: number): void {
-    const lines = this.planLayout.draftText;
-    if (lines.length === 0) return;
-    const step = Math.sign(delta) || 1;
-    let target = Math.max(0, Math.min(lines.length - 1, this.planCursor + delta));
-    while (target > 0 && target < lines.length - 1 && !lines[target]!.trim()) target += step;
-    if (!lines[target]?.trim()) {
-      // Ran into a blank edge: look back the other way for the nearest line with text.
-      let back = target;
-      while (back >= 0 && back < lines.length && !lines[back]!.trim()) back -= step;
-      if (back >= 0 && back < lines.length) target = back;
-    }
-    this.planCursor = target;
-    this.keepCursorVisible();
-  }
-
-  private keepCursorVisible(): void {
-    const rows = Math.max(1, this.planLayout.draftRows);
-    const start = Math.min(this.planDraftOffset, Math.max(0, this.planLayout.draftText.length - rows));
-    if (this.planCursor < start) this.planDraftOffset = this.planCursor;
-    else if (this.planCursor >= start + rows) this.planDraftOffset = this.planCursor - rows + 1;
-    else this.planDraftOffset = start;
-  }
-
-  /** Put the draft cursor on the first line with text on screen. */
-  private cursorToView(): void {
-    const lines = this.planLayout.draftText;
-    const start = this.planLayout.draftStart;
-    const end = Math.min(lines.length, start + Math.max(1, this.planLayout.draftRows));
-    if (this.planCursor >= start && this.planCursor < end && lines[this.planCursor]?.trim()) return;
-    for (let index = start; index < end; index++) {
-      if (lines[index]?.trim()) {
-        this.planCursor = index;
-        return;
-      }
-    }
-    this.planCursor = start;
-  }
-
-  private selectTask(index: number): void {
-    const rows = this.taskRowList();
-    this.tasksSelected = Math.max(0, Math.min(rows.length - 1, index));
-    this.tasksDetailOffset = 0;
-    // Only the newly selected task's comments: moving through the list must not reread every task from disk.
-    const row = rows[this.tasksSelected];
-    if (row?.kind === "task" && !this.data.comments.has(row.id)) this.data.comments.set(row.id, this.host.comments(row.id));
-  }
-
-  private async loadPullDetail(): Promise<void> {
-    const pull = this.host.pulls.pulls[this.gitSelected];
-    if (pull) await this.host.pulls.detail(pull.number);
-  }
-
-  private async loadIssueDetail(): Promise<void> {
-    const issue = this.host.issues.issues[this.issueSelected];
-    if (issue) await this.host.issues.detail(issue.number);
-  }
-
-  /** The tab's single-key commands in browsing mode; true when the key was one. */
-  private tabCommand(data: string): boolean {
-    const enter = matchesKey(data, Key.enter);
-    const escape = matchesKey(data, Key.escape);
-    switch (this.tab) {
-      case "lobby": {
-        const background = this.viewedSession();
-        if (escape && background?.busy) {
-          background.abort();
-          this.say(`stopping ${background.name}'s oracle…`);
-          return true;
-        }
-        if (escape && this.viewing.kind === "here" && this.host.masterBusy()) {
-          this.host.abortMaster();
-          this.say("stopping the oracle…");
-          return true;
-        }
-        if (data === "c") {
-          const task = this.viewedEntry().task;
-          if (task && !TERMINAL_STATES.includes(task.state)) this.commentOn(task.id);
-          else this.say("no task in this session to comment on", "warning");
-          return true;
-        }
-        if (data === "s" && this.viewing.kind !== "here") {
-          this.switchTo(this.viewedEntry());
-          return true;
-        }
-        return enter ? (this.setMode("type"), true) : false;
-      }
-      case "tasks":
-        return this.tasksCommand(data, enter, escape);
-      case "plan":
-        return this.planCommand(data, enter, escape);
-      case "quickfix":
-        if (enter) return (this.fixFocus = this.fixFocus === "list" ? "detail" : "list"), true;
-        if (escape && this.fixFocus === "detail") return (this.fixFocus = "list"), true;
-        if (data === "x") {
-          const job = this.fixJobs()[this.fixSelected];
-          if (job && this.host.quickfix.cancel(job.id)) this.say(`cancelling ${job.id}`);
-          return true;
-        }
-        if (data === "m") return this.openSettings("quickfix"), true;
-        if (data === "r" || data === "t") {
-          const job = this.fixJobs()[this.fixSelected];
-          // Only a held job takes r and t; otherwise the key resumes typing like any other.
-          if (!job || job.status !== "held") return false;
-          if (data === "r" && this.host.quickfix.runAnyway(job.id)) this.say(`running ${job.id} anyway`);
-          if (data === "t") {
-            this.startInNewSession({ request: job.prompt });
-            this.host.quickfix.movedToTask(job.id);
-          }
-          return true;
-        }
-        return false;
-      case "issues":
-        return this.issuesCommand(data, enter, escape);
-      case "git":
-        return this.gitCommand(data, enter, escape);
-      case "knowledge":
-        return this.knowledgeCommand(data, enter, escape);
-      case "excalidraw":
-        return this.excalidrawCommand(data, enter, escape);
-      case "metrics":
-        if (data === "g") return (this.metricsBy = this.metricsBy === "model" ? "model-kind" : "model", this.metricsSelected = 0), true;
-        if (data === "s") return (this.metricsSort = SORT_KEYS[(SORT_KEYS.indexOf(this.metricsSort) + 1) % SORT_KEYS.length]!), true;
-        if (data === "r") return this.refreshData(true), true;
-        return false;
-    }
-  }
-
-  private tasksCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const row = this.taskRowList()[this.tasksSelected];
-    if (enter) return (this.tasksFocus = this.tasksFocus === "list" ? "detail" : "list"), true;
-    if (escape) return (this.tasksFocus = "list"), true;
-    if (data === "r") return this.refreshData(true), true;
-    if (data === "n") return this.startNewSessionPrompt(), true;
-    if (data === "v") {
-      this.showArchived = !this.showArchived;
-      this.refreshData(true);
-      const count = this.data.archived.length;
-      this.say(this.showArchived ? (count > 0 ? `showing ${count} archived task${count === 1 ? "" : "s"} — a restores one, d d deletes it` : "the archive is empty") : "archived tasks hidden");
-      return true;
-    }
-    if (data === "A") return this.archiveFinished(), true;
-    if (!row) return false;
-    if (row.kind === "archived") return this.archivedCommand(row, data);
-    if ((data === "a" || data === "d") && row.kind === "task") return this.archiveOrDelete(row, data === "a" ? "archive" : "delete"), true;
-    if (data === "c") {
-      const task = this.data.tasks.find((entry) => entry.id === row.id);
-      if (row.kind !== "task" || !task) this.say("pick a task to comment on its plan", "warning");
-      else if (TERMINAL_STATES.includes(task.state)) this.say(`${task.id} is ${task.state}; there is no plan left to change`, "warning");
-      else {
-        this.commentTarget = task.id;
-        this.setMode("type");
-      }
-      return true;
-    }
-    const plan = row.kind === "plan" ? this.data.plans.find((entry) => entry.id === row.id) : undefined;
-    // A planned task starts in a new session of its own (s), or in this window (h).
-    if (data === "s" && plan) {
-      this.startInNewSession({ plan });
-      return true;
-    }
-    if (data === "h" && plan) {
-      this.say(this.host.startPlanned(plan));
-      this.refreshData(true);
-      return true;
-    }
-    const task = row.kind === "task" ? this.data.tasks.find((entry) => entry.id === row.id) : undefined;
-    if (data === "o" && task) {
-      const target = this.sessionEntries().find((entry) => entry.task?.id === task.id);
-      if (!target) this.say(`${task.id} is not running in any session now`, "warning");
-      else {
-        this.view(target.view);
-        this.say(target.view.kind === "here" ? "this window's task" : `showing ${target.name}`);
-      }
-      return true;
-    }
-    if (data === "x" && task) {
-      const session = this.host.sessions().find((entry) => entry.alive && entry.sessionId === task.ownerSessionId);
-      if (!session) return this.say("only a background session this window started can be stopped from here", "warning"), true;
-      if (this.armed !== `stop:${session.key}`) {
-        this.armed = `stop:${session.key}`;
-        this.say(`press x again to stop ${session.name} (its task keeps its state)`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      session.stop();
-      this.say(`stopping ${session.name}`);
-      return true;
-    }
-    if (data === "d" && plan) {
-      if (this.armed !== `discard:${plan.id}`) {
-        this.armed = `discard:${plan.id}`;
-        this.say(`press d again to discard ${plan.id}`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      this.host.discardPlan(plan.id);
-      this.say(`discarded ${plan.id}`);
-      this.refreshData(true);
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Archive (a) or delete (d d) a task on the list. Deleting always asks for
-   * the key twice; archiving a task still under way does too, since it is
-   * abandoned first.
-   */
-  private archiveOrDelete(row: TaskRow, action: "archive" | "delete"): void {
-    const task = this.data.tasks.find((entry) => entry.id === row.id);
-    if (!task) return;
-    const open = !TERMINAL_STATES.includes(task.state);
-    const armed = `${action}:${task.id}`;
-    if ((action === "delete" || open) && this.armed !== armed) {
-      this.armed = armed;
-      const key = action === "delete" ? "d" : "a";
-      this.say(action === "delete" ? `press ${key} again to delete ${task.id} for good` : `${task.id} is ${task.state.replace(/_/g, " ")} — press a again to abandon and archive it`, "warning");
-      return;
-    }
-    this.armed = undefined;
-    const notice = action === "archive" ? this.host.archiveTask(task.id) : this.host.deleteTask(task.id, "list");
-    this.say(notice, /^(archived|deleted)/.test(notice) ? "info" : "warning");
-    this.refreshData(true);
-  }
-
-  /** Keys on an archived task: a restores it, d d deletes it. */
-  private archivedCommand(row: TaskRow, data: string): boolean {
-    if (data === "a") {
-      const notice = this.host.restoreTask(row.id);
-      this.say(notice, notice.startsWith("restored") ? "info" : "warning");
-      this.refreshData(true);
-      return true;
-    }
-    if (data === "d") {
-      if (this.armed !== `purge:${row.id}`) {
-        this.armed = `purge:${row.id}`;
-        this.say(`press d again to delete ${row.id} for good`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      const notice = this.host.deleteTask(row.id, "archive");
-      this.say(notice, notice.startsWith("deleted") ? "info" : "warning");
-      this.refreshData(true);
-      return true;
-    }
-    return false;
-  }
-
-  /** Archive every finished task at once (A twice). */
-  private archiveFinished(): void {
-    const finished = this.data.tasks.filter((task) => TERMINAL_STATES.includes(task.state));
-    if (finished.length === 0) return this.say("no finished tasks to archive", "warning");
-    if (this.armed !== "archive-all") {
-      this.armed = "archive-all";
-      return this.say(`press A again to archive all ${finished.length} finished task${finished.length === 1 ? "" : "s"}`, "warning");
-    }
-    this.armed = undefined;
-    const failed = finished.map((task) => this.host.archiveTask(task.id)).filter((notice) => !notice.startsWith("archived"));
-    this.refreshData(true);
-    this.say(failed.length === 0 ? `archived ${finished.length} finished task${finished.length === 1 ? "" : "s"} — v shows them` : `archived ${finished.length - failed.length}; ${failed[0]}`, failed.length === 0 ? "info" : "warning");
-  }
-
-  /** Seats for the next round: the session's, or the ones chosen before it started. */
-  private seatSet(): Set<PanelMember> {
-    const session = this.host.planner();
-    if (session) return session.seats;
-    this.seats ??= new Set(this.host.defaultPanel());
-    return this.seats;
-  }
-
-  private resetPlanScroll(): void {
-    this.planOffset = 0;
-    this.planDraftOffset = 0;
-    this.planCursor = 0;
-  }
-
-  /** The Lobby prompt: a new task in its own session, or a message to the session in view. */
-  private submitLobby(body: string): void {
-    this.homeOffsets.conversation = 0;
-    if (this.newSession) {
-      this.newSession = false;
-      return this.startInNewSession({ request: body });
-    }
-    const view = this.viewing;
-    if (view.kind === "background") {
-      const session = this.viewedSession();
-      if (!session?.alive) {
-        this.editor.setText(body);
-        return this.say(`${session?.name ?? "that session"} has ended — alt+n starts a new one`, "warning");
-      }
-      session.send(body);
-      return;
-    }
-    if (view.kind === "other") return this.say(this.host.sendToSession(view.sessionId, body));
-    if (view.kind === "idle") return this.say(this.host.sendToTask(view.taskId, body));
-    const notice = this.host.toOracle(body);
-    if (notice) this.say(notice);
-  }
-
-  /** Put the question the background session in view waits on to the user. */
-  private answerSessionDialog(): void {
-    const session = this.viewedSession();
-    if (!session?.dialogs.length) return;
-    void this.host.answerDialog(session).then(() => this.host.requestRender());
-  }
-
-  /* -------------------------------------------------------------- history */
-
-  /**
-   * The whole conversation of the session in view, loaded when the
-   * conversation pane is scrolled back past the messages kept in memory, and
-   * let go once it is back at the newest.
-   */
-  private history?: { view: SessionView; entries: readonly ChatEntry[] };
-
-  /** The conversation to draw for the session in view, and whether earlier messages wait to be loaded. */
-  private conversationFor(entry: SessionEntry): { chat: readonly ChatEntry[]; older: boolean } {
-    if (this.history && sameView(this.history.view, entry.view)) return { chat: this.history.entries, older: false };
-    if (entry.view.kind === "here") return { chat: this.host.feed.chat, older: this.host.feed.chatOlder };
-    if (entry.view.kind === "background") {
-      const session = this.viewedSessionFor(entry.view.key);
-      return { chat: session?.feed.chat ?? [], older: Boolean(session?.feed.chatOlder && session.sessionId) };
-    }
-    return entry.sessionId ? { chat: this.host.sessionChat(entry.sessionId), older: this.host.hasOlderChat(entry.sessionId) } : { chat: [], older: false };
-  }
-
-  /**
-   * After the conversation pane scrolls: at its top, with earlier messages
-   * waiting, load the whole conversation; back at its newest, let it go.
-   * True when history was loaded now.
-   */
-  private followHistory(): boolean {
-    if (this.tab !== "lobby") return false;
-    if (this.homeOffsets.conversation === 0) {
-      this.history = undefined;
-      return false;
-    }
-    if (this.history && sameView(this.history.view, this.viewing)) return false;
-    const pane = this.panes.get("conversation");
-    if (!pane || this.homeOffsets.conversation < pane.total - pane.rows) return false;
-    const entry = this.viewedEntry();
-    if (!this.conversationFor(entry).older) return false;
-    const sessionId = entry.view.kind === "here" ? undefined : entry.view.kind === "background" ? this.viewedSessionFor(entry.view.key)?.sessionId : entry.sessionId;
-    if (entry.view.kind !== "here" && !sessionId) return false;
-    const entries = this.host.chatHistory(sessionId);
-    if (entries.length === 0) return false;
-    this.history = { view: entry.view, entries };
-    return true;
-  }
-
-  /* ------------------------------------------------------------ sessions */
-
-  /** Every session the lobby can show: this window, the background sessions it started, then tasks other terminals drive. */
-  sessionEntries(): SessionEntry[] {
-    const me = this.host.sessionId();
-    const zen = this.host.zen();
-    const background = this.host.sessions();
-    const started = new Set(background.map((session) => session.sessionId).filter((id): id is string => Boolean(id)));
-    const auto = (task: Task | undefined) => Boolean(task && !TERMINAL_STATES.includes(task.state) && this.host.isAuto(task.id));
-    const entries: SessionEntry[] = [{
-      view: { kind: "here" },
-      name: this.host.sessionName() ?? zen.task?.title ?? "unnamed session",
-      where: "this window",
-      ...(zen.task ? { task: zen.task } : {}),
-      status: this.host.masterBusy() ? "working" : zen.task?.state ?? "no task",
-      auto: auto(zen.task),
-      waiting: 0,
-    }];
-    const active = (sessionId: string | undefined) => (sessionId ? this.data.tasks.find((task) => task.ownerSessionId === sessionId && !TERMINAL_STATES.includes(task.state)) : undefined);
-    for (const session of background) {
-      const task = active(session.sessionId);
-      const status = session.status === "exited" ? "ended" : session.status === "starting" ? "starting" : session.busy ? "working" : task?.state ?? "idle";
-      entries.push({ view: { kind: "background", key: session.key }, name: session.name, where: "background", ...(task ? { task } : {}), status, auto: auto(task), waiting: session.dialogs.length, ...(session.sessionId ? { sessionId: session.sessionId } : {}) });
-    }
-    const running = new Set<string>([...(me ? [me] : []), ...started]);
-    for (const live of this.host.liveSessions()) {
-      if (running.has(live.sessionId)) continue;
-      running.add(live.sessionId);
-      const task = active(live.sessionId);
-      entries.push({ view: { kind: "other", sessionId: live.sessionId }, name: live.name ?? task?.title ?? "unnamed session", where: "other terminal", ...(task ? { task } : {}), status: task?.state ?? "no task", auto: auto(task), waiting: 0, sessionId: live.sessionId, pid: live.pid });
-    }
-    // Tasks under way whose session is not running (it ended, or none ever owned them): they can be resumed here.
-    for (const task of this.data.tasks) {
-      if (TERMINAL_STATES.includes(task.state) || (task.ownerSessionId && running.has(task.ownerSessionId))) continue;
-      entries.push({ view: { kind: "idle", taskId: task.id }, name: task.title, where: "not running", task, status: task.state, auto: auto(task), waiting: 0, ...(task.ownerSessionId ? { sessionId: task.ownerSessionId } : {}) });
-    }
-    return entries;
-  }
-
-  /**
-   * The entry the Lobby tab shows. A task that was not running follows its
-   * session once one picks it up; a session that is gone falls back to this
-   * window.
-   */
-  viewedEntry(): SessionEntry {
-    const entries = this.sessionEntries();
-    const view = this.viewing;
-    if (view.kind === "here") return entries[0]!;
-    let found = entries.find((entry) => sameView(entry.view, view));
-    if (!found && view.kind === "idle") found = entries.find((entry) => entry.task?.id === view.taskId);
-    if (!found) this.viewing = { kind: "here" };
-    else this.viewing = found.view;
-    return found ?? entries[0]!;
-  }
-
-  private viewedSession(): BackgroundSession | undefined {
-    const view = this.viewing;
-    return view.kind === "background" ? this.host.sessions().find((session) => session.key === view.key) : undefined;
-  }
-
-  /** Show a session in the Lobby tab, and talk to it from there. */
-  view(target: SessionView): void {
-    this.viewing = target;
-    this.picking = false;
-    this.newSession = false;
-    this.history = undefined;
-    for (const pane of HOME_PANES) this.homeOffsets[pane] = 0;
-    if (this.tab !== "lobby") this.setTab("lobby");
-    this.setMode("type");
-  }
-
-  private openPicker(): void {
-    this.help = false;
-    this.picking = true;
-    const entries = this.sessionEntries();
-    const current = this.viewedEntry();
-    this.pickIndex = Math.max(0, entries.findIndex((entry) => sameView(entry.view, current.view)));
-  }
-
-  /**
-   * Run a session in this window: a background one is stopped and resumed
-   * here, a task nobody runs is resumed (or claimed) here. A session running
-   * in another terminal stays there — two pi processes must not write one
-   * session.
-   */
-  switchTo(entry: SessionEntry): void {
-    if (entry.view.kind === "here") return this.say("this is this window's session");
-    if (entry.where === "other terminal") return this.say(`${entry.name} is running in another terminal${entry.pid ? ` (pid ${entry.pid})` : ""} — switch there, or close it first and resume it here`, "warning");
-    if (this.host.masterBusy()) return this.say("this window's oracle is working — esc stops it, then switch", "warning");
-    const background = entry.view.kind === "background" ? this.host.sessions().find((session) => entry.view.kind === "background" && session.key === entry.view.key) : undefined;
-    const target: SwitchTarget = {
-      name: entry.name,
-      ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
-      ...(background ? { background } : {}),
-      ...(!entry.sessionId && entry.task ? { claimTaskId: entry.task.id } : {}),
-    };
-    this.picking = false;
-    this.say(background ? `stopping ${entry.name}'s background process to resume it here…` : `switching this window to ${entry.name}…`);
-    void this.host.switchTo(target).then((notice) => {
-      this.say(notice);
-      this.host.requestRender();
-    });
-  }
-
-  /** Keys while the session switcher is open; true when the key was handled. */
-  private pickerKey(data: string, action: LobbyAction | undefined): boolean {
-    const entries = this.sessionEntries();
-    this.pickIndex = Math.min(this.pickIndex, Math.max(0, entries.length - 1));
-    if (matchesKey(data, Key.escape) || action === "sessions") {
-      this.picking = false;
-      return true;
-    }
-    if (matchesKey(data, Key.up) || data === "k") return (this.pickIndex = Math.max(0, this.pickIndex - 1)), true;
-    if (matchesKey(data, Key.down) || data === "j") return (this.pickIndex = Math.min(entries.length - 1, this.pickIndex + 1)), true;
-    const entry = entries[this.pickIndex];
-    if (matchesKey(data, Key.enter) && entry) {
-      this.view(entry.view);
-      this.say(entry.view.kind === "here" ? "back to this window" : `showing ${entry.name} — you talk to its oracle from here`);
-      return true;
-    }
-    if (data === "s" && entry) {
-      this.switchTo(entry);
-      return true;
-    }
-    if (data === "n" || action === "newSession") {
-      this.picking = false;
-      this.startNewSessionPrompt();
-      return true;
-    }
-    if (data === "x" && entry?.view.kind === "background") {
-      const key = entry.view.key;
-      if (this.armed !== `stop:${key}`) {
-        this.armed = `stop:${key}`;
-        this.say(`press x again to stop ${entry.name} (its task keeps its state)`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      this.host.sessions().find((session) => session.key === key)?.stop();
-      this.say(`stopping ${entry.name}`);
-      return true;
-    }
-    return true;
-  }
-
-  /** Start typing a task that begins in its own new session. */
-  startNewSessionPrompt(): void {
-    this.picking = false;
-    this.help = false;
-    if (this.tab !== "lobby") this.setTab("lobby");
-    this.newSession = true;
-    this.setMode("type");
-  }
-
-  /** Start a task in a new background session and show it. */
-  startInNewSession(start: { request?: string; plan?: PlannedTask }): void {
-    const session = this.host.startSession(start);
-    if (typeof session === "string") return this.say(session, "warning");
-    this.view({ kind: "background", key: session.key });
-    this.say(`started ${session.name} in a new session — alt+o switches back`);
-    this.refreshData(true);
-  }
-
-  /** The task auto mode applies to: the selected row on the Tasks tab, the viewed session's task elsewhere. */
-  private autoTarget(): Task | undefined {
-    if (this.tab === "tasks") {
-      const row = this.taskRowList()[this.tasksSelected];
-      return row?.kind === "task" ? this.data.tasks.find((task) => task.id === row.id) : undefined;
-    }
-    return this.viewedEntry().task;
-  }
-
-  /** Switch auto mode for the task in view. */
-  toggleAuto(): void {
-    const task = this.autoTarget();
-    if (!task || TERMINAL_STATES.includes(task.state)) return this.say("no active task here — auto mode applies to a task", "warning");
-    const on = !this.host.isAuto(task.id);
-    this.host.setAuto(task.id, on);
-    this.say(on ? `auto mode on — the oracle drives ${task.id} to completion without asking` : `auto mode off — the oracle asks you again on ${task.id}`);
-  }
-
-  /**
-   * Save the planning session's draft to the pending tasks, from any tab and
-   * in either mode. A plan with many steps is first offered a split into
-   * several tasks, which takes the oracle a moment and asks the user.
-   */
-  savePlan(): void {
-    const session = this.host.planner();
-    if (!session?.reply?.plan) return this.say(session?.busy ? "the first draft is still being written" : "no plan to save yet — describe a task in the Plan tab", "warning");
-    void this.host.savePlan().then(
-      (notice) => {
-        this.say(notice);
-        this.refreshData(true);
-        this.host.requestRender();
-      },
-      (error: Error) => {
-        this.say(error.message, "warning");
-        this.host.requestRender();
-      },
-    );
-  }
-
-  /** The oracle puts the round's questions to the user through the questionnaire. */
-  answerQuestions(): void {
-    const session = this.host.planner();
-    if (!session?.awaitingAnswers) return this.say(session?.busy ? "the panel is still thinking" : "no open questions", "warning");
-    void this.host.answerPanel().then((notice) => {
-      this.say(notice);
-      this.host.requestRender();
-    });
-  }
-
-  /** Start a comment on the draft line under the cursor. */
-  private commentOnCursor(): void {
-    const line = this.planLayout.draftText[this.planCursor];
-    if (!this.host.planner()?.reply?.plan) return this.say("there is no draft to comment on yet", "warning");
-    if (!line?.trim()) return this.say("that line is blank — ↑↓ picks another", "warning");
-    this.lineTarget = line.trim();
-    this.setMode("type");
-  }
-
-  private planCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const session = this.host.planner();
-    if (enter) {
-      this.planFocus = this.planFocus === "talk" ? "draft" : "talk";
-      if (this.planFocus === "draft") this.cursorToView();
-      return true;
-    }
-    if (data === "a") {
-      this.answerQuestions();
-      return true;
-    }
-    if (data === "m") {
-      this.openSettings("planner");
-      return true;
-    }
-    if (data === "c") {
-      if (this.planFocus !== "draft") {
-        this.planFocus = "draft";
-        this.cursorToView();
-        this.say("↑↓ picks a draft line, c comments on it (or click the line)");
-        return true;
-      }
-      this.commentOnCursor();
-      return true;
-    }
-    const seat = /^[1-4]$/.test(data) ? PANEL_MEMBERS[Number(data) - 1] : undefined;
-    if (seat) {
-      let seated: boolean;
-      if (session) seated = session.toggle(seat);
-      else {
-        const seats = this.seatSet();
-        seated = !seats.delete(seat);
-        if (seated) seats.add(seat);
-      }
-      this.say(`${MEMBER_LABELS[seat]} ${seated ? "joins the panel from the next round and sits every round" : "leaves the panel from the next round"}`);
-      return true;
-    }
-    if (data === "x" || (escape && session?.busy)) {
-      if (session?.busy) {
-        session.cancel();
-        this.say("stopping the panel…");
-      }
-      return true;
-    }
-    if (escape && this.planFocus === "draft") {
-      this.planFocus = "talk";
-      return true;
-    }
-    if (data === "r") {
-      if (session?.retryable) void session.retry();
-      else this.say("nothing to retry", "warning");
-      return true;
-    }
-    if (data === "n") {
-      const unsaved = session && session.messages.length > 0 && !session.saved;
-      if (unsaved && this.armed !== "new-plan") {
-        this.armed = "new-plan";
-        this.say("this plan is not saved — press n again to start over anyway", "warning");
-        return true;
-      }
-      this.armed = undefined;
-      session?.cancel();
-      this.host.newPlanner(undefined, [...this.seatSet()]);
-      this.resetPlanScroll();
-      this.setMode("type");
-      return true;
-    }
-    return false;
-  }
-
-  private issuesCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const issue = this.host.issues.issues[this.issueSelected];
-    if (enter) {
-      this.issueFocus = this.issueFocus === "list" ? "detail" : "list";
-      void this.loadIssueDetail();
-      return true;
-    }
-    if (escape) return (this.issueFocus = "list"), true;
-    if (data === "r") {
-      this.host.issues.details.clear();
-      void this.host.issues.refresh().then(() => this.loadIssueDetail());
-      return true;
-    }
-    if (data === "n") {
-      this.issueDraft = true;
-      this.setMode("type");
-      return true;
-    }
-    if (data === "p" && issue) {
-      void this.planIssue(issue.number);
-      return true;
-    }
-    return false;
-  }
-
-  /** The selected pull request on the Git tab. */
-  private selectedPull() {
-    return this.host.pulls.pulls[this.gitSelected];
-  }
-
-  /** Review the selected pull request with a read-only agent, optionally looking at `focus` first. */
-  private startReview(focus?: string): void {
-    const pull = this.selectedPull();
-    if (!pull) return this.say("no pull request selected — r loads the open ones", "warning");
-    if (this.host.reviews.running(pull.number)) return this.say(`already reviewing #${pull.number} — x stops it`, "warning");
-    this.gitFocus = "detail";
-    this.gitDetailOffset = 0;
-    this.say(`reviewing #${pull.number}${focus ? ` — looking at: ${clip(focus, 40)}` : ""} — it streams into the activity log; x stops it`);
-    void this.host.reviews.start(pull.number, { ...(focus ? { focus } : {}), ...(this.host.pulls.details.has(pull.number) ? { detail: this.host.pulls.details.get(pull.number)! } : {}) }).then(() => this.host.requestRender());
-  }
-
-  private gitCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const pull = this.selectedPull();
-    if (enter) {
-      this.gitFocus = this.gitFocus === "list" ? "detail" : "list";
-      void this.loadPullDetail();
-      return true;
-    }
-    if (escape) return (this.gitFocus = "list"), true;
-    if (data === "r") {
-      this.host.pulls.forget();
-      void this.host.pulls.refresh().then(() => this.loadPullDetail());
-      return true;
-    }
-    if (!pull) {
-      // Nothing listed: the review keys say so instead of doing nothing.
-      if (!"vftx".includes(data) || data.length !== 1) return false;
-      this.say("no pull request selected — r loads the open ones", "warning");
-      return true;
-    }
-    if (data === "v") return this.startReview(), true;
-    if (data === "f") {
-      this.gitFocusDraft = true;
-      this.setMode("type");
-      return true;
-    }
-    if (data === "t") {
-      this.gitFocus = "detail";
-      this.gitDetailOffset = 0;
-      this.say(`asking Jev to read #${pull.number}…`);
-      void this.host.reviews.readWithJev(pull.number, this.host.pulls.details.get(pull.number)).then(() => this.host.requestRender());
-      return true;
-    }
-    if (data === "x") {
-      this.say(this.host.reviews.cancel(pull.number) ? `stopping the review of #${pull.number}` : `no review of #${pull.number} is running`, "warning");
-      return true;
-    }
-    return false;
-  }
-
-  /** The picked entry of the open knowledge file, as the edit functions find it again. */
-  private pickedEntry(): { entry: EntryRef; text: string } | undefined {
-    const entry = this.data.knowledge.view?.entries[this.kCursor];
-    return entry ? { entry: { text: entry.text, occurrence: entry.occurrence }, text: entry.text } : undefined;
-  }
-
-  private knowledgeCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const info = this.data.knowledge.files[this.kSelected];
-    if (enter) return (this.kFocus = this.kFocus === "list" ? "detail" : "list"), true;
-    if (escape) return (this.kFocus = "list"), true;
-    if (data === "r") {
-      this.reloadKnowledge();
-      this.say("knowledge reread from disk");
-      return true;
-    }
-    if (!info) return false;
-    if (data === "E") {
-      const view = this.data.knowledge.view;
-      if (!view) return true;
-      void this.host.editText(`${info.label} — ${info.agent}/${info.file}`, view.content).then((text) => {
-        if (text !== undefined) this.say(this.host.knowledge.replaceFile(info.agent, info.file, text));
-        this.reloadKnowledge();
-        this.host.requestRender();
-      });
-      return true;
-    }
-    if (!"ecndx".includes(data) || data.length !== 1) return false;
-    const picked = this.pickedEntry();
-    // Adding needs no entry to start from: it goes at the end of an empty or entry-less file.
-    if (!picked && data !== "n") {
-      this.say("nothing is picked — n adds an entry", "warning");
-      return true;
-    }
-    this.kFocus = "detail";
-    if (data === "e" && picked) {
-      this.kDraft = { kind: "edit", entry: picked.entry };
-      this.editor.setText(picked.text);
-      this.setMode("type");
-      return true;
-    }
-    if (data === "c" && picked) {
-      this.kDraft = { kind: "comment", entry: picked.entry };
-      this.setMode("type");
-      return true;
-    }
-    if (data === "n") {
-      this.kDraft = { kind: "add", ...(picked ? { entry: picked.entry } : {}) };
-      this.setMode("type");
-      return true;
-    }
-    if (data === "d" && picked) {
-      const key = `kdelete:${info.agent}/${info.file}:${picked.entry.occurrence}:${picked.text}`;
-      if (this.armed !== key) {
-        this.armed = key;
-        this.say("press d again to delete this entry (the file is archived first, and its notes go with it)", "warning");
-        return true;
-      }
-      this.armed = undefined;
-      this.say(this.host.knowledge.remove(info.agent, info.file, picked.entry));
-      this.reloadKnowledge();
-      return true;
-    }
-    if (data === "x" && picked) {
-      const notes = this.data.knowledge.view?.attached.filter((note) => note.entry === picked.text) ?? [];
-      const newest = notes.at(-1);
-      if (!newest) {
-        this.say("this entry has no notes", "warning");
-        return true;
-      }
-      const key = `kunnote:${newest.id}`;
-      if (this.armed !== key) {
-        this.armed = key;
-        this.say(`press x again to remove the note “${clip(newest.text, 40)}”`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      this.say(this.host.knowledge.unnote(newest.id));
-      this.reloadKnowledge();
-      return true;
-    }
-    return true;
-  }
-
-  /** Assign the picked session to the agent under the cursor, or take it back. */
-  private toggleExcalidrawAgent(session: ExcalidrawSession): void {
-    this.say(this.host.excalidraw.toggleAgent(session.id, EXCALIDRAW_AGENTS[this.xAgent]!));
-    this.data.excalidraw = this.host.excalidraw.list();
-  }
-
-  private excalidrawCommand(data: string, enter: boolean, escape: boolean): boolean {
-    const sessions = this.data.excalidraw;
-    const session = sessions[this.xSelected];
-    if (data === "a" || data === "n") {
-      if (sessions.length >= MAX_SESSIONS) {
-        this.say(`all ${MAX_SESSIONS} sessions are in use — remove one first (d d)`, "warning");
-        return true;
-      }
-      this.xDraft = data === "a" ? "add" : "new";
-      this.xFocus = "list";
-      this.setMode("type");
-      return true;
-    }
-    if (escape) return (this.xFocus = "list"), true;
-    if (!session) return false;
-    if (enter || (data === " " && this.xFocus === "detail")) {
-      if (this.xFocus === "list") this.xFocus = "detail";
-      else this.toggleExcalidrawAgent(session);
-      return true;
-    }
-    if (data === "*") {
-      this.say(this.host.excalidraw.toggleAll(session.id));
-      this.data.excalidraw = this.host.excalidraw.list();
-      return true;
-    }
-    if (data === "w") {
-      this.say(this.host.excalidraw.toggleContribute(session.id));
-      this.data.excalidraw = this.host.excalidraw.list();
-      return true;
-    }
-    if (data === "r") {
-      this.xDraft = "rename";
-      this.editor.setText(session.name);
-      this.setMode("type");
-      return true;
-    }
-    if (data === "t") {
-      if (this.xChecking.has(session.id)) return true;
-      this.xChecking.add(session.id);
-      this.xChecks.delete(session.id);
-      void this.host.checkExcalidraw(session).then((result) => {
-        this.xChecking.delete(session.id);
-        this.xChecks.set(session.id, result);
-        this.host.requestRender();
-      });
-      return true;
-    }
-    if (data === "d") {
-      const key = `xdelete:${session.id}`;
-      if (this.armed !== key) {
-        this.armed = key;
-        this.say(`press d again to remove “${session.name}” (agents lose it at once; the room itself is untouched)`, "warning");
-        return true;
-      }
-      this.armed = undefined;
-      this.say(this.host.excalidraw.remove(session.id));
-      this.xChecks.delete(session.id);
-      this.data.excalidraw = this.host.excalidraw.list();
-      this.xSelected = Math.max(0, Math.min(this.xSelected, this.data.excalidraw.length - 1));
-      return true;
-    }
-    return false;
-  }
-
-  /** The prompt's text on the Excalidraw tab: a link to add (a name may follow it), the name of a new room, or a new name. */
-  private submitExcalidraw(body: string): void {
-    const draft = this.xDraft;
-    if (!draft) {
-      this.editor.setText(body);
-      return this.say("press a to add a session from a link, n for a new room", "warning");
-    }
-    const book = this.host.excalidraw;
-    if (draft === "rename") {
-      const session = this.data.excalidraw[this.xSelected];
-      this.xDraft = undefined;
-      this.setMode("browse");
-      if (session) this.say(book.rename(session.id, body));
-      this.data.excalidraw = book.list();
-      return;
-    }
-    // A link, then optionally a name for it; or the link's name first.
-    const parts = body.split(/\s+/);
-    const linkAt = parts.findIndex((part) => part.includes("#room=") || /^[\w-]+,[\w-]{22}$/.test(part));
-    const added = draft === "add" ? (linkAt < 0 ? { notice: "that is not an Excalidraw room link — it looks like https://excalidraw.com/#room=<id>,<key>" } : book.add(parts[linkAt]!, parts.filter((_, index) => index !== linkAt).join(" "))) : book.create(body);
-    if (!added.session) {
-      // Keep what was typed, so a slip in the link can be fixed.
-      this.editor.setText(body);
-      return this.say(added.notice, "warning");
-    }
-    this.xDraft = undefined;
-    this.setMode("browse");
-    this.data.excalidraw = book.list();
-    this.xSelected = Math.max(0, this.data.excalidraw.findIndex((session) => session.id === added.session!.id));
-    this.xFocus = "detail";
-    this.xAgent = 0;
-    this.say(added.notice);
-  }
-
-  /** The prompt's text on the Knowledge tab: an edit of the picked entry, a note on it, or a new entry after it. */
-  private submitKnowledge(body: string): void {
-    const draft = this.kDraft;
-    const info = this.data.knowledge.files[this.kSelected];
-    if (!draft || !info) {
-      this.editor.setText(body);
-      return this.say("press e to edit the picked entry, c to comment on it, n to add one", "warning");
-    }
-    this.kDraft = undefined;
-    this.setMode("browse");
-    const book = this.host.knowledge;
-    const notice = draft.kind === "edit" ? book.edit(info.agent, info.file, draft.entry!, body) : draft.kind === "comment" ? book.comment(info.agent, info.file, draft.entry!, body) : book.add(info.agent, info.file, draft.entry, body);
-    this.say(notice, /^(saved|note saved)/.test(notice) ? "info" : "warning");
-    this.reloadKnowledge();
-    // A new entry goes right after the picked one, which the cursor then moves onto.
-    if (draft.kind === "add" && notice.startsWith("saved")) this.kCursor = Math.min(this.kCursor + (draft.entry ? 1 : 0), Math.max(0, (this.data.knowledge.view?.entries.length ?? 1) - 1));
-  }
-
-  /* --------------------------------------------------------------- mouse */
-
-  /** Mouse events when pi runs full screen (pi-tui dispatches them to the overlay). */
-  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
-    if (event.type === "wheel") this.wheel(Math.sign(event.wheelDelta ?? 0) || 1, event.x, event.y);
-    else if (event.type === "click" && event.button === "left") this.click(event.x, event.y);
-    else return undefined;
-    this.host.requestRender();
-    return { handled: true };
-  }
-
-  /** Mouse reports in pi's regular screen, where the lobby turns reporting on itself. */
-  private mouseReport(report: MouseReport): void {
-    if (report.kind === "wheel") this.wheel(report.delta, report.x, report.y);
-    else if (report.kind === "press" && report.button === 0) this.click(report.x, report.y);
-  }
-
-  /** The pane of the current tab under a body cell, if any. */
-  private paneAt(x: number, y: number): string | undefined {
-    const row = y - this.bodyTop;
-    for (const [name, pane] of this.panes) {
-      if (row >= pane.top && row < pane.top + pane.height && x >= pane.left && x < pane.left + pane.width) return name;
-    }
-    return undefined;
-  }
-
-  /** The wheel scrolls the pane under the pointer (the focused one when it is over none). */
-  private wheel(direction: number, x = -1, y = -1): void {
-    if (this.help) return;
-    if (this.tab === "issues" || this.tab === "git" || this.tab === "knowledge" || this.tab === "excalidraw") return this.scroll(direction * WHEEL_LINES);
-    this.scrollPane(this.paneAt(x, y) ?? this.focusedPane(), direction * WHEEL_LINES, true);
-  }
-
-  /** A click: a tab in the tab bar, the prompt, or a line of the draft plan to comment on. */
-  click(x: number, y: number): void {
-    this.help = false;
-    if (y === 0) {
-      const span = this.tabSpans.find((entry) => x >= entry.from && x < entry.to);
-      if (span) this.setTab(span.tab);
-      return;
-    }
-    if (y >= this.promptTop) {
-      if (this.searching) this.closeSearch();
-      if (this.tab !== "metrics" && this.tab !== "tasks") this.setMode("type");
-      return;
-    }
-    const row = y - this.bodyTop;
-    // A click on a pane gives it the keys.
-    const pane = this.paneAt(x, y);
-    if (this.tab === "lobby" && pane) this.homeFocus = pane as HomePane;
-    if (this.tab === "tasks" && (pane === "list" || pane === "detail")) this.tasksFocus = pane;
-    if (this.tab === "quickfix" && (pane === "list" || pane === "detail")) this.fixFocus = pane;
-    // The page buttons in a scrolling pane's bottom border scroll it a page or two.
-    const paneBox = pane ? this.panes.get(pane) : undefined;
-    if (pane && paneBox && paneBox.total > paneBox.rows && row === paneBox.top + paneBox.height - 1) {
-      const button = pagerButton(paneBox.width, x - paneBox.left, paneBox.total, paneBox.rows);
-      if (button) {
-        this.scrollPane(pane, button * pageStep(paneBox.rows), false, true);
-        return;
-      }
-    }
-    if (this.tab !== "plan" || row < 0 || !this.host.planner()) return;
-    const layout = this.planLayout;
-    // The draft pane: its border sits one row above its first line and two columns left of its text.
-    const inDraftColumns = x >= layout.draftLeft - 2 && x < layout.draftLeft + layout.draftWidth + 2;
-    const line = row - layout.draftTop;
-    if (inDraftColumns && line >= -1 && line <= layout.draftRows) {
-      this.planFocus = "draft";
-      const index = layout.draftStart + line;
-      if (line < 0 || line >= layout.draftRows || index >= layout.draftText.length) return;
-      this.planCursor = index;
-      if (this.searching) this.closeSearch();
-      this.commentOnCursor();
-      return;
-    }
-    // The conversation sits left of the draft on wide terminals, above it on narrow ones.
-    const inTalk = layout.draftLeft > 2 ? x < layout.draftLeft - 2 : line < -1;
-    if (inTalk) this.planFocus = "talk";
-  }
-
-  /* -------------------------------------------------------------- submit */
-
-  private submit(text: string): void {
-    const body = text.trim();
-    if (!body) {
-      if (this.tab === "knowledge" && this.kDraft) return this.say(this.kDraft.kind === "edit" ? "nothing to save — d d deletes an entry, esc cancels" : "write something first, or esc to cancel", "warning");
-      // A new room's name is optional: an empty enter makes it with a numbered one.
-      if (this.tab === "excalidraw" && this.xDraft === "new") return this.submitExcalidraw("");
-      if (this.tab === "excalidraw" && this.xDraft) return this.say(this.xDraft === "add" ? "paste the session's link first, or esc to cancel" : "write a name first, or esc to cancel", "warning");
-      // An empty enter on the Plan tab opens the panel's questions; on the Lobby, a background session's question.
-      if (this.tab === "plan" && !this.lineTarget && this.host.planner()?.awaitingAnswers) this.answerQuestions();
-      if (this.tab === "lobby" && !this.newSession) this.answerSessionDialog();
-      return;
-    }
-    this.editor.addToHistory(body);
-    switch (this.tab) {
-      case "lobby":
-        return this.submitLobby(body);
-      case "tasks":
-        if (!this.commentTarget) {
-          this.editor.setText(body);
-          return this.say("press c on a task to comment on its plan", "warning");
-        }
-        this.say(this.host.comment(this.commentTarget, body));
-        this.commentTarget = undefined;
-        this.setMode("browse");
-        this.refreshData(true);
-        return;
-      case "plan":
-        return this.submitPlan(body);
-      case "quickfix": {
-        const job = this.host.quickfix.submit(body);
-        this.fixSelected = 0;
-        this.fixDetailOffset = 0;
-        delete this.queries.quickfix;
-        this.say(this.host.quickfix.running?.id === job.id ? `${job.id} started` : `${job.id} queued behind the running quick fix`);
-        return;
-      }
-      case "issues":
-        if (!this.issueDraft) {
-          this.editor.setText(body);
-          return this.say("press n to file a new issue", "warning");
-        }
-        this.issueDraft = false;
-        this.setMode("browse");
-        this.say("filing the issue…");
-        void this.host.issues.create(body);
-        return;
-      case "knowledge":
-        return this.submitKnowledge(body);
-      case "excalidraw":
-        return this.submitExcalidraw(body);
-      case "git":
-        if (!this.gitFocusDraft) {
-          this.editor.setText(body);
-          return this.say("press f to review the selected pull request with a focus", "warning");
-        }
-        this.gitFocusDraft = false;
-        this.setMode("browse");
-        return this.startReview(body);
-      case "metrics":
-        return;
-    }
-  }
-
-  private submitPlan(body: string): void {
-    if (this.lineTarget) {
-      const line = this.lineTarget;
-      this.lineTarget = undefined;
-      const session = this.host.planner();
-      if (!session) return this.say("there is no draft to comment on", "warning");
-      const sent = session.commentOnLine(line, body);
-      this.planFocus = "draft";
-      this.setMode("browse");
-      if (sent) this.say("comment sent — the panel revises the draft");
-      else if (session.busy) this.say("comment kept — it goes to the panel after this round");
-      else this.say("comment kept — it goes with your answers (a answers the questions)");
-      return;
-    }
-    const session = this.host.planner() ?? this.host.newPlanner(undefined, [...this.seatSet()]);
-    if (session.busy) {
-      this.editor.setText(body);
-      return this.say("the panel is still thinking — x stops it", "warning");
-    }
-    this.planOffset = 0;
-    this.planDraftOffset = 0;
-    session.send(body).catch((error: Error) => this.say(error.message, "warning"));
-  }
-
-  /* -------------------------------------------------------------- render */
-
-  /** Bumped each time the data is reread. */
-  private dataVersion = 0;
-  /** Task rows as last built: several parts of a frame ask, and they only change with the data, the search or the clock. */
-  private rowsMemo?: { key: string; rows: TaskRow[] };
-
-  /** The Metrics tab's figures as last computed: they change only with the data, the grouping, the order or the search. */
-  private metricsMemo?: { key: string; figures: ReturnType<LobbyView["computeMetrics"]> };
-
-  private metricsFigures(query: string | undefined) {
-    const key = `${this.dataVersion}|${this.metricsBy}|${this.metricsSort}|${query ?? ""}`;
-    if (this.metricsMemo?.key !== key) this.metricsMemo = { key, figures: this.computeMetrics(query) };
-    return this.metricsMemo.figures;
-  }
-
-  private computeMetrics(query: string | undefined) {
-    const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
-    return {
-      records,
-      groups: sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort),
-      taskTimes: taskTimesByModel(this.data.tasks, records),
-      stats: taskStats(this.data.tasks),
-      jev: summarizeClassifier(this.data.classifierMetrics, records),
-    };
-  }
-
-  /** Task rows, narrowed by the Tasks tab's search. */
-  private taskRowList(): TaskRow[] {
-    const key = `${this.dataVersion}|${this.tick}|${this.showArchived}|${this.queries.tasks ?? ""}`;
-    if (this.rowsMemo?.key === key) return this.rowsMemo.rows;
-    const rows = this.buildTaskRows();
-    this.rowsMemo = { key, rows };
-    return rows;
-  }
-
-  private buildTaskRows(): TaskRow[] {
-    const names = new Map<string, string>();
-    for (const session of this.host.sessions()) if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
-    const auto = new Set(this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && this.host.isAuto(task.id)).map((task) => task.id));
-    const live = new Set(this.host.liveSessions().map((session) => session.sessionId));
-    const rows = taskRows(this.data.tasks, this.data.plans, this.host.sessionId(), this.now(), { names, auto, live, archived: this.data.archived });
-    return filterRows(rows, this.data.tasks, this.data.plans, this.queries.tasks);
-  }
-
-  /** Quick fix jobs as listed: newest first, narrowed by the search. */
-  private fixJobs() {
-    return newestFirst(filterJobs(this.host.quickfix.jobs, this.queries.quickfix));
-  }
-
-  private tabBar(width: number, theme: LobbyTheme): string {
-    const zen = this.host.zen();
-    const badges: Partial<Record<TabId, string>> = {};
-    const active = this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state)).length;
-    if (active > 0) badges.tasks = String(active);
-    const session = this.host.planner();
-    if (session?.busy) badges.plan = spinner(this.tick);
-    else if (session?.awaitingAnswers) badges.plan = `${session.questions.length}?`;
-    if (this.host.quickfix.running) badges.quickfix = spinner(this.tick);
-    if (this.issuesOn && this.host.issues.issues.length > 0) badges.issues = String(this.host.issues.issues.length);
-    if (this.host.reviews.busy) badges.git = spinner(this.tick);
-    else if (this.host.pulls.pulls.length > 0) badges.git = String(this.host.pulls.pulls.length);
-    if (this.data.excalidraw.length > 0) badges.excalidraw = String(this.data.excalidraw.length);
-    const cells = this.tabs().map((tab, index) => {
-      const number = paint(theme, tab === this.tab ? "accent" : "dim", String(index + 1));
-      const name = tab === this.tab ? bold(theme, paint(theme, "text", TAB_LABELS[tab])) : paint(theme, "muted", TAB_LABELS[tab]);
-      const badge = badges[tab] ? ` ${paint(theme, tab === "plan" && session?.awaitingAnswers ? "warning" : "accent", badges[tab]!)}` : "";
-      const cell = ` ${number} ${name}${badge} `;
-      return { tab, text: tab === this.tab ? (theme.bg ? theme.bg("selectedBg", cell) : `[${cell}]`) : cell };
-    });
-    const entry = this.viewedEntry();
-    const help = paint(theme, "dim", `${keyLabel(this.keys.help)} keys `);
-    const auto = entry.auto ? ` ${bold(theme, paint(theme, "success", "⟳ AUTO"))}` : "";
-    const waiting = this.host.sessions().reduce((count, session) => count + session.dialogs.length, 0);
-    const asking = waiting > 0 ? ` ${paint(theme, "warning", `● ${waiting} waiting · ${keyLabel(this.keys.sessions)}`)}` : "";
-    // Short of room, the key to open the sessions goes before the waiting count does.
-    const asked = waiting > 0 ? ` ${paint(theme, "warning", `● ${waiting} waiting`)}` : "";
-    let choices: string[];
-    if (entry.view.kind !== "here") {
-      // Another session in view: its name and what it is doing lead, so it is never mistaken for this window.
-      const working = entry.status === "working";
-      const dot = paint(theme, working ? "accent" : "dim", working ? spinner(this.tick) : "◆");
-      const where = paint(theme, "muted", `${entry.name} · ${entry.status}`);
-      choices = [`${dot} ${where}${auto}${asking}  ${help}`, `${dot} ${where}${auto}${asking} `, `${dot} ${where}${auto}${asked} `, `${dot}${auto}${asked} `, `${dot} ${where}${auto} `, `${dot}${auto} `];
-    } else {
-      const dot = paint(theme, this.host.masterBusy() ? "accent" : "dim", this.host.masterBusy() ? spinner(this.tick) : "●");
-      const state = zen.task ? paint(theme, "muted", zen.task.paused ? `${zen.task.state} (paused)` : zen.task.state) : "";
-      // Long task ids give way to the state, then to the dot alone.
-      choices = zen.task
-        ? [`${dot} ${zen.task.id} ${state}${auto}${asking}  ${help}`, `${dot} ${zen.task.id} ${state}${auto}${asking} `, `${dot} ${zen.task.id} ${state}${auto}${asked} `, `${dot} ${state}${auto}${asked} `, `${dot}${auto}${asked} `, `${dot} ${state}${auto} `, `${dot}${auto} `]
-        : [`${paint(theme, "dim", "no task in this session")}${asking}  ${help}`, `${paint(theme, "dim", "no task in this session")}${asking} `, `${paint(theme, "dim", "no task in this session")}${asked} `, `${asked.trimStart()} `, help, ""];
-    }
-    // The longest title that leaves room for the tabs and, when a session waits on you, for saying so.
-    const tabsWidth = cells.reduce((sum, cell) => sum + textWidth(cell.text), 0);
-    const titles = this.titles(entry.task, theme);
-    let brand = titles.at(-1)!;
-    let status = "";
-    for (const [index, title] of titles.entries()) {
-      const room = width - textWidth(title) - 1 - tabsWidth - 1;
-      const shown = choices.find((choice) => textWidth(choice) <= room) ?? "";
-      if (index === titles.length - 1 || (room >= 0 && (waiting === 0 || shown.includes("waiting")))) {
-        brand = title;
-        status = shown;
-        break;
-      }
-    }
-    let left = `${brand}${paint(theme, "borderMuted", "│")}`;
-    const spans: Array<{ tab: TabId; from: number; to: number }> = [];
-    for (const cell of cells) {
-      const from = textWidth(left);
-      left += cell.text;
-      spans.push({ tab: cell.tab, from, to: textWidth(left) });
-    }
-    this.tabSpans = spans;
-    const gap = width - textWidth(left) - textWidth(status);
-    return gap >= 1 ? `${left}${" ".repeat(gap)}${status}` : fit(left, width);
-  }
-
-  /**
-   * The lobby's title, longest first: the repository (or folder) it works
-   * from and the branch, `◆ my-repo (⎇ main)`, then the name alone, then just
-   * the mark. A task with a worktree of its own shows that branch, since that
-   * is where its work happens.
-   */
-  private titles(task: Task | undefined, theme: LobbyTheme): string[] {
-    const workspace = this.host.workspace?.();
-    const name = clip(workspace?.name || "bot-lobby", TITLE_NAME_MAX);
-    const own = task?.git?.mode === "worktree" ? task.git.branch : undefined;
-    const branch = own ?? workspace?.branch;
-    const glyph = paint(theme, "accent", " ◆ ");
-    const label = (text: string) => bold(theme, paint(theme, "accent", text));
-    return [
-      ...(branch ? [`${glyph}${label(name)} ${paint(theme, "muted", `(${BRANCH_GLYPH} ${clip(branch, TITLE_BRANCH_MAX)})`)} `] : []),
-      `${glyph}${label(name)} `,
-      glyph,
-    ];
-  }
-
-  private promptLabel(): string {
-    const zen = this.host.zen();
-    const browsing = this.mode === "browse";
-    switch (this.tab) {
-      case "lobby": {
-        if (this.newSession) return "new task — it starts in its own session, named after it";
-        if (this.viewing.kind !== "here") {
-          const entry = this.viewedEntry();
-          const session = this.viewedSession();
-          if (session && !session.alive) return `${entry.name} has ended`;
-          if (session?.dialogs.length) return `press enter to answer ${entry.name}'s question, or type a message`;
-          if (entry.where === "not running") return `leave ${entry.name} a message for when it resumes · esc, s resumes it here`;
-          return entry.where === "other terminal" ? `message ${entry.name}'s oracle (its own session delivers it)` : `message ${entry.name}'s oracle`;
-        }
-        if (!zen.task) return browsing ? "describe a task to start — i to type" : "describe a task to start · enter starts it";
-        return browsing ? "message the oracle — i to type" : this.host.masterBusy() ? "message the oracle · enter steers the running turn" : "message the oracle";
-      }
-      case "tasks":
-        return this.commentTarget ? `comment on ${this.commentTarget}'s plan · enter sends it to the oracle` : "c comments on the selected task's plan";
-      case "plan": {
-        if (this.lineTarget) return `comment on “${clip(this.lineTarget, 48)}”`;
-        const session = this.host.planner();
-        if (session?.busy) return "the panel is thinking";
-        if (session?.awaitingAnswers) {
-          const count = session.questions.length;
-          return `press enter to answer ${count} question${count === 1 ? "" : "s"}, or type a reply`;
-        }
-        if (session?.reply?.status === "ready") return `the plan is ready — ${keyLabel(this.keys.savePlan)} saves it, or reply to refine it`;
-        return session && session.messages.length > 0 ? "reply to the panel" : "describe the task to plan";
-      }
-      case "quickfix":
-        return this.host.quickfix.running ? "describe a quick change; it runs after the current one" : "describe a quick change";
-      case "issues":
-        return this.issueDraft ? "new issue · first line is the title" : "n files a new issue";
-      case "knowledge": {
-        const picked = this.pickedEntry();
-        if (this.kDraft?.kind === "edit") return `edit “${clip(picked?.text ?? "", 40)}” · enter saves it · esc cancels`;
-        if (this.kDraft?.kind === "comment") return `a note on “${clip(picked?.text ?? "", 40)}” — every agent reads it under the entry · enter saves`;
-        if (this.kDraft?.kind === "add") return picked ? `a new entry after “${clip(picked.text, 40)}” · enter adds it` : "a new entry · enter adds it";
-        return "e edits the picked entry, c comments on it, n adds one";
-      }
-      case "excalidraw": {
-        if (this.xDraft === "add") return "paste the session's link (a name may follow it) · enter adds it · esc cancels";
-        if (this.xDraft === "new") return "a name for the new room (optional) · enter makes it · esc cancels";
-        if (this.xDraft === "rename") return "a new name for the session · enter saves it · esc cancels";
-        return "a adds a session from a link, n makes a new room";
-      }
-      case "git": {
-        const pull = this.selectedPull();
-        if (this.gitFocusDraft) return `what should the review of #${pull?.number ?? "?"} look at first? · enter reviews`;
-        return pull ? `f reviews #${pull.number} with a focus you type, v without one` : "r loads the open pull requests";
-      }
-      case "metrics":
-        return "";
-    }
-  }
-
-  private promptLines(width: number, theme: LobbyTheme): string[] {
-    if (this.tab === "metrics") return [];
-    const typing = this.mode === "type" && !this.searching;
-    this.editor.label = this.promptLabel();
-    this.editor.paintLabel = (text) => paint(theme, typing ? (this.lineTarget ? "warning" : "accent") : "dim", text);
-    this.editor.borderColor = (text) => paint(theme, typing ? "border" : "borderMuted", text);
-    const lines = this.editor.render(width);
-    // The editor always draws its block cursor; while browsing it would suggest the prompt has focus.
-    return typing ? lines : lines.map((line) => line.replace(REVERSE_VIDEO, "$1"));
-  }
-
-  /** The search bar: the query being typed, or the one in force. */
-  private searchLines(width: number, theme: LobbyTheme): string[] {
-    const query = this.query();
-    if (!this.searching && !query) return [];
-    const lead = `${paint(theme, "accent", " / ")}`;
-    const tail = this.searching
-      ? paint(theme, "dim", " enter keep · esc clear · ↑↓ browse results ")
-      : paint(theme, "dim", ` ${keyLabel(this.keys.search)} or / edits · esc clears `);
-    const room = Math.max(4, width - textWidth(lead) - textWidth(tail));
-    const field = this.searching ? this.search.render(room)[0] ?? "" : bold(theme, fit(query ?? "", room));
-    return [fit(`${lead}${fit(field, room)}${tail}`, width)];
-  }
-
-  /** Every key the current tab understands while browsing. */
-  private tabKeys(): KeyHelp[] {
-    switch (this.tab) {
-      case "lobby":
-        return [
-          { key: "type", text: "talk to the oracle of the session in view (in this window, starts a task when none is running)" },
-          { key: "enter", text: "on an empty prompt: answer the question a background session waits on" },
-          { key: "s", text: "run the session in view in this window: a background one moves here, a task nobody runs resumes here" },
-          { key: "↑ ↓", text: "scroll the focused pane (PageUp/PageDown a page)" },
-          { key: "← →", text: "move between the conversation, activity log and thinking" },
-          { key: "Home End", text: "the oldest lines, or back to the newest" },
-          { key: "c", text: "comment on this task's plan" },
-          { key: "esc", text: "stop the oracle while it works" },
-        ];
-      case "tasks":
-        return [
-          { key: "↑ ↓", text: "select a task or plan, or scroll the detail (PageUp/PageDown)" },
-          { key: "enter / ← →", text: "move between the list and the detail" },
-          { key: "c", text: "comment on the selected task's plan" },
-          { key: "s", text: "start the selected planned task in a new session, named after it" },
-          { key: "h", text: "start the selected planned task here, in this window" },
-          { key: "n", text: "type a new task that starts in its own session" },
-          { key: "o", text: "show the session driving the selected task in the Lobby tab" },
-          { key: "x x", text: "stop the background session driving the selected task" },
-          { key: "d d", text: "discard the selected planned task, or delete the selected task for good" },
-          { key: "a", text: "archive the selected task (a task under way is abandoned first: a twice), or restore an archived one" },
-          { key: "A A", text: "archive every finished task" },
-          { key: "v", text: "show or hide archived tasks" },
-          { key: "r", text: "reread tasks from disk" },
-        ];
-      case "plan":
-        return [
-          { key: "a", text: "answer the panel's questions, one questionnaire at a time (enter on an empty prompt too)" },
-          { key: "enter / ← →", text: "move between the conversation and the draft" },
-          { key: "↑ ↓", text: "pick a draft line (draft) or scroll (conversation); PageUp/PageDown a page" },
-          { key: "c / click", text: "comment on the picked draft line" },
-          { key: "1-4", text: "seat or unseat DEV, DESIGN, QA, RESEARCH" },
-          { key: "n", text: "start a new plan" },
-          { key: "x", text: "stop the round" },
-          { key: "r", text: "retry a failed round or seat" },
-          { key: "m", text: "the oracle's model, thinking and time limit (Planner settings)" },
-        ];
-      case "quickfix":
-        return [
-          { key: "type", text: "describe a quick change" },
-          { key: "↑ ↓", text: "select a quick fix, or scroll the detail (PageUp/PageDown)" },
-          { key: "enter / ← →", text: "move between the list and the detail" },
-          { key: "x", text: "cancel the selected quick fix" },
-          { key: "m", text: "the quick fix agent's model, thinking, time limit and instructions" },
-        ];
-      case "issues":
-        return [
-          { key: "↑ ↓", text: "select an issue" },
-          { key: "enter", text: "read the selected issue" },
-          { key: "p", text: "plan the selected issue" },
-          { key: "n", text: "file a new issue" },
-          { key: "r", text: "reload issues" },
-        ];
-      case "knowledge":
-        return [
-          { key: "↑ ↓", text: "pick a file, or (in the entries) pick an entry; PageUp/PageDown several" },
-          { key: "enter / ← →", text: "move between the files and their entries" },
-          { key: "e", text: "edit the picked entry: it comes into the prompt (Shift+Enter for a new line, enter saves)" },
-          { key: "c", text: "comment on it: a note every agent reads under that entry" },
-          { key: "n", text: "add an entry after the picked one" },
-          { key: "d d", text: "delete the picked entry, and its notes" },
-          { key: "x x", text: "take back the newest note on the picked entry" },
-          { key: "E", text: "edit the whole file in pi's editor" },
-          { key: "r", text: "reread the files from disk" },
-        ];
-      case "excalidraw":
-        return [
-          { key: "↑ ↓", text: "pick a session, or (in the checklist) an agent" },
-          { key: "enter / ← →", text: "move between the sessions and the agents; in the checklist, enter or space assigns the picked agent" },
-          { key: "a", text: "add a session: paste the link from Excalidraw (Share → Live collaboration → Start session)" },
-          { key: "n", text: "make a new room, whose link you open in Excalidraw" },
-          { key: "*", text: "assign the session to every agent, or (when they all have it) to none" },
-          { key: "w", text: "let agents draw in the session, or only look at it" },
-          { key: "t", text: "check the session: join the room for a moment and report who is there and what is on the board" },
-          { key: "r", text: "rename the session" },
-          { key: "d d", text: "remove the session (agents lose it at once)" },
-        ];
-      case "git":
-        return [
-          { key: "↑ ↓", text: "select a pull request, or scroll its detail (PageUp/PageDown)" },
-          { key: "enter / ← →", text: "move between the list and the detail" },
-          { key: "v", text: "review it with a read-only agent on QA's model (nothing is posted to GitHub)" },
-          { key: "f", text: "review it with a focus you type first (Shift+Enter for a new line, enter reviews)" },
-          { key: "t", text: "Jev's quick read: size, risk, security, breaking changes, missing tests" },
-          { key: "x", text: "stop the review that is running" },
-          { key: "r", text: "reload the pull requests" },
-        ];
-      case "metrics":
-        return [
-          { key: "↑ ↓", text: "select a row of the table" },
-          { key: "g", text: "group by model, or by model and agent" },
-          { key: "s", text: "change the sort" },
-          { key: "r", text: "reread the metrics log" },
-        ];
-    }
-  }
-
-  private chips(entries: ReadonlyArray<readonly [string, string]>, theme: LobbyTheme): string {
-    return entries.map(([key, text]) => `${paint(theme, "accent", key)} ${paint(theme, "dim", text)}`).join(paint(theme, "dim", "  "));
-  }
-
-  private hintLine(width: number, theme: LobbyTheme): string {
-    const notice = this.notice && this.now() - this.notice.at < NOTICE_MS ? this.notice : undefined;
-    if (notice) return fit(paint(theme, notice.kind === "warning" ? "warning" : "accent", ` ${notice.text}`), width);
-    const k = (action: LobbyAction) => keyLabel(this.keys[action]).toLowerCase();
-    const badge = (text: string, color: "accent" | "muted" | "warning") => {
-      const label = bold(theme, paint(theme, color, ` ${text} `));
-      return theme.bg ? theme.bg("selectedBg", label) : label;
-    };
-    if (this.help) return fit(`${badge("KEYS", "accent")} ${this.chips([["any key", "closes"]], theme)}`, width);
-    if (this.searching) return fit(`${badge("SEARCH", "warning")} ${this.chips([["enter", "keep"], ["esc", "clear"], ["↑↓", "results"], [k("nextTab"), "next tab"]], theme)}`, width);
-    const mode = this.mode === "type" ? badge("TYPE", "accent") : badge("BROWSE", "muted");
-    const keys = `${mode} ${this.chips(this.hintChips(), theme)}`;
-    // The subagents at work sit at the right end of the line, when the keys leave room.
-    const working = this.viewing.kind === "here" ? agentsIndicator(workingAgents(this.host.zen().runs, this.host.quickfix.running), this.now(), spinner(this.tick), width - textWidth(keys) - 3, theme) : "";
-    const gap = width - textWidth(keys) - textWidth(working) - 1;
-    return working && gap >= 2 ? `${keys}${" ".repeat(gap)}${working} ` : fit(keys, width);
-  }
-
-  /**
-   * The few keys that matter right now, most useful first: typing names what
-   * enter does here; browsing names the tab's main commands, only those that
-   * apply. Everything else is one `?` away.
-   */
-  private hintChips(): Array<[string, string]> {
-    const k = (action: LobbyAction) => keyLabel(this.keys[action]).toLowerCase();
-    const session = this.host.planner();
-    if (this.picking) return [["↑↓", "browse"], ["enter", "view"], ["s", "switch here"], ["x x", "stop"], ["n", "new"], ["esc", "close"]];
-    if (this.mode === "type") {
-      if (this.tab === "lobby" && this.newSession) return [["enter", "start in a new session"], ["esc", "cancel"]];
-      if (this.tab === "lobby" && this.viewing.kind !== "here") {
-        const background = this.viewedSession();
-        if (background?.dialogs.length && !this.editor.getText().trim()) return [["enter", "answer its question"], [k("sessions"), "sessions"], [k("hide"), "hide"]];
-        return [["enter", background?.busy ? "steer" : "send"], [k("sessions"), "sessions"], [k("toggleAuto"), "auto"]];
-      }
-      if (this.tab === "lobby" && this.host.masterBusy()) return [["enter", "steer"], ["esc", "stop the oracle"], [k("hide"), "hide"]];
-      if (this.tab === "plan" && this.lineTarget) return [["enter", "add the comment"], ["esc", "cancel"]];
-      if (this.tab === "knowledge" && this.kDraft) return [["enter", this.kDraft.kind === "edit" ? "save" : this.kDraft.kind === "comment" ? "save the note" : "add it"], ["shift+enter", "new line"], ["esc", "cancel"]];
-      if (this.tab === "excalidraw" && this.xDraft) return [["enter", this.xDraft === "add" ? "add it" : this.xDraft === "new" ? "make it" : "save"], ["esc", "cancel"]];
-      if (this.tab === "git" && this.gitFocusDraft) return [["enter", "review with this focus"], ["shift+enter", "new line"], ["esc", "cancel"]];
-      const enter = this.tab === "plan" && session?.awaitingAnswers && !this.editor.getText().trim() ? "answer questions" : this.tab === "quickfix" ? "run it" : "send";
-      return [["enter", enter], ["esc", "browse"], [k("hide"), "hide"]];
-    }
-    const keys: Array<[string, string]> = [];
-    switch (this.tab) {
-      case "lobby":
-        keys.push(["←→", "pane"], ["↑↓", "scroll"], [k("sessions"), "sessions"], [k("newSession"), "new session"]);
-        if (this.viewing.kind === "background" || this.viewing.kind === "idle") keys.push(["s", "switch here"]);
-        if (this.viewedEntry().task) keys.push([k("toggleAuto"), "auto"], ["c", "comment on plan"]);
-        break;
-      case "tasks": {
-        const row = this.taskRowList()[this.tasksSelected];
-        keys.push(["↑↓", "select"]);
-        const finished = row?.kind === "task" && TERMINAL_STATES.includes(row.status as Task["state"]);
-        if (row?.kind === "task" && !finished) keys.push(["c", "comment"], ["o", "open its session"], [k("toggleAuto"), "auto"]);
-        if (row?.kind === "task") keys.push(["a", "archive"], ["d d", "delete"]);
-        if (row?.kind === "archived") keys.push(["a", "restore"], ["d d", "delete"]);
-        if (row?.kind === "plan") keys.push(["s", "start in a new session"], ["h", "start here"], ["d", "discard"]);
-        keys.push(["v", this.showArchived ? "hide archived" : "archived"], ["n", "new task"]);
-        break;
-      }
-      case "plan":
-        if (session?.awaitingAnswers) keys.push(["a", "answer"]);
-        if (session?.reply?.plan) keys.push([k("savePlan"), "save"], ["c", "comment on a line"]);
-        if (session?.busy) keys.push(["x", "stop"]);
-        keys.push(["n", "new"], ["1-4", "seats"]);
-        break;
-      case "quickfix":
-        if (this.host.quickfix.jobs.length > 0) keys.push(["↑↓", "select"], ["x", "cancel"]);
-        if (this.fixJobs()[this.fixSelected]?.status === "held") keys.push(["r", "run anyway"], ["t", "as a task"]);
-        keys.push(["m", "model"]);
-        break;
-      case "issues":
-        keys.push(["↑↓", "select"], ["p", "plan it"], ["n", "new"]);
-        break;
-      case "knowledge":
-        keys.push(["↑↓", "pick"], ["enter", this.kFocus === "list" ? "entries" : "files"]);
-        if (this.kFocus === "detail" || this.pickedEntry()) keys.push(["e", "edit"], ["c", "comment"], ["n", "new"], ["d d", "delete"]);
-        keys.push(["E", "edit file"]);
-        break;
-      case "excalidraw": {
-        const session = this.data.excalidraw[this.xSelected];
-        keys.push(["a", "add a link"], ["n", "new room"]);
-        if (session) keys.push(["↑↓", this.xFocus === "detail" ? "agent" : "session"], ["enter", this.xFocus === "detail" ? "assign" : "agents"], ["t", "check"], ["w", session.contribute ? "look only" : "let agents draw"], ["d d", "remove"]);
-        break;
-      }
-      case "git": {
-        const pull = this.selectedPull();
-        keys.push(["↑↓", "select"]);
-        if (pull) keys.push(["v", "review"], ["f", "review with a focus"], ["t", "Jev's read"]);
-        if (pull && this.host.reviews.running(pull.number)) keys.push(["x", "stop"]);
-        keys.push(["r", "reload"]);
-        break;
-      }
-      case "metrics":
-        keys.push(["↑↓", "select"], ["g", "group"], ["s", "sort"]);
-        break;
-    }
-    return [...keys, ["?", "all keys"]];
-  }
-
-  /** The help screen: every shortcut, the typing and browsing keys, and this tab's commands. */
-  private helpBody(width: number, height: number, theme: LobbyTheme): string[] {
-    const keyWidth = 13;
-    const row = (key: string, text: string, inner: number) => wrapHanging(`${paint(theme, "accent", fit(key, keyWidth))} `, text, inner);
-    const section = (title: string) => bold(theme, paint(theme, "mdHeading", title));
-    const tabs = this.tabs();
-    const everywhere = (inner: number) => [
-      section("Everywhere"),
-      ...(Object.keys(LOBBY_ACTIONS) as LobbyAction[]).flatMap((action) => row(keyLabel(this.keys[action]), LOBBY_ACTIONS[action].help, inner)),
-      ...row(`Alt+1…${tabs.length}`, "jump to a tab", inner),
-      ...row("Ctrl+C", "clear the prompt, or hide the lobby", inner),
-      ...row("click", "a tab to open it, a pane to give it the keys, a draft plan line to comment on it", inner),
-      ...row("wheel", "scroll the pane under the pointer", inner),
-      ...row("prev next", "click on a long pane's bottom edge (▲ prev · page 2/5 · next ▼) to move a page; dimmed at either end", inner),
-    ];
-    const modes = (inner: number) => [
-      section("Typing"),
-      ...row("Enter", "send", inner),
-      ...row("Shift+Enter", "new line", inner),
-      ...row("Esc", "stop typing and browse", inner),
-      "",
-      section("Browsing"),
-      ...row("i", "type", inner),
-      ...row("/", "search this tab (esc clears)", inner),
-      ...row("?", "these keys", inner),
-      "",
-      section(`${TAB_LABELS[this.tab]} tab`),
-      ...this.tabKeys().flatMap((entry) => row(entry.key, entry.text, inner)),
-    ];
-    const footer = paint(theme, "dim", "Rebind any shortcut under lobby.keys in the bot-lobby config, e.g. { \"toggleThinking\": \"alt+t\" }. Hidden panes stay hidden next time (lobby.panels); lobby.mouse turns clicks off.");
-    const title = { title: "Keys", right: "any key closes", focused: true, theme } as const;
-    if (width >= 100) {
-      const left = Math.floor((width - 1) / 2);
-      const inner = left - 4;
-      const columns = beside([
-        box(left, height, [...everywhere(inner), "", ...wrapHanging("", footer, inner)], title),
-        box(width - 1 - left, height, modes(width - 1 - left - 4), { focused: true, theme }),
-      ]);
-      return columns;
-    }
-    const inner = width - 4;
-    return box(width, height, [...everywhere(inner), "", ...modes(inner), "", ...wrapHanging("", footer, inner)], title);
-  }
-
-  private body(width: number, height: number, theme: LobbyTheme): string[] {
-    const now = this.now();
-    const query = this.query();
-    this.panes.clear();
-    switch (this.tab) {
-      case "lobby":
-        return this.homeBody(width, height, theme, now);
-      case "tasks":
-        return this.tasksBody(width, height, theme, now);
-      case "plan": {
-        const session = this.host.planner();
-        const lines = renderPlan({
-          ...(session ? { session: this.planView(session) } : {}),
-          profile: this.host.profileLabel("planner"),
-          seats: this.seatViews(undefined),
-          limit: this.host.planningRounds?.() ?? 0,
-          offset: this.planOffset,
-          focus: this.planFocus,
-          draftOffset: this.planDraftOffset,
-          cursor: this.planCursor,
-          tick: this.tick,
-          ...(query ? { query } : {}),
-          layout: this.planLayout,
-          panes: this.panes,
-          saveKey: keyLabel(this.keys.savePlan),
-        }, width, height, theme);
-        if (!session) Object.assign(this.planLayout, { draftRows: 0, draftStart: 0, draftText: [] });
-        this.planCursor = Math.min(this.planCursor, Math.max(0, this.planLayout.draftText.length - 1));
-        return lines;
-      }
-      case "quickfix":
-        this.fixSelected = Math.min(this.fixSelected, Math.max(0, this.fixJobs().length - 1));
-        return renderQuickFix({ jobs: this.host.quickfix.jobs, selected: this.fixSelected, focus: this.fixFocus, detailOffset: this.fixDetailOffset, profile: this.host.profileLabel("quickfix"), tick: this.tick, now, ...(query ? { query } : {}), panes: this.panes }, width, height, theme);
-      case "issues": {
-        const issues = this.host.issues;
-        this.issueSelected = Math.min(this.issueSelected, Math.max(0, issues.issues.length - 1));
-        const selected = issues.issues[this.issueSelected];
-        const detail = selected ? issues.details.get(selected.number) : undefined;
-        return renderIssues({
-          issues: issues.issues, selected: this.issueSelected, ...(detail ? { detail } : {}), focus: this.issueFocus, detailOffset: this.issueDetailOffset,
-          loading: issues.loading, loaded: issues.loaded, ...(issues.error ? { error: issues.error } : {}), ...(issues.notice ? { notice: issues.notice } : {}), tick: this.tick, now,
-        }, width, height, theme);
-      }
-      case "knowledge": {
-        const knowledge = this.data.knowledge;
-        this.kSelected = Math.min(this.kSelected, Math.max(0, knowledge.files.length - 1));
-        this.kCursor = Math.min(this.kCursor, Math.max(0, (knowledge.view?.entries.length ?? 1) - 1));
-        const lines = renderKnowledge({ files: knowledge.files, selected: this.kSelected, ...(knowledge.view ? { view: knowledge.view } : {}), cursor: this.kCursor, focus: this.kFocus, offset: this.kOffset, layout: this.kLayout }, width, height, theme);
-        this.kOffset = this.kLayout.offset;
-        return lines;
-      }
-      case "excalidraw": {
-        this.xSelected = Math.min(this.xSelected, Math.max(0, this.data.excalidraw.length - 1));
-        return renderExcalidraw({ sessions: this.data.excalidraw, selected: this.xSelected, focus: this.xFocus, agent: this.xAgent, checks: this.xChecks, checking: this.xChecking, tick: this.tick }, width, height, theme);
-      }
-      case "git": {
-        const pulls = this.host.pulls;
-        this.gitSelected = Math.min(this.gitSelected, Math.max(0, pulls.pulls.length - 1));
-        const selected = pulls.pulls[this.gitSelected];
-        const detail = selected ? pulls.details.get(selected.number) : undefined;
-        const review = selected ? this.host.reviews.review(selected.number) : undefined;
-        const read = selected ? this.host.reviews.reads.get(selected.number) : undefined;
-        return renderGit({
-          pulls: pulls.pulls, selected: this.gitSelected, ...(detail ? { detail } : {}), ...(review ? { review } : {}), ...(read ? { read } : {}),
-          focus: this.gitFocus, detailOffset: this.gitDetailOffset, loading: pulls.loading, loaded: pulls.loaded, ...(pulls.error ? { error: pulls.error } : {}), tick: this.tick, now,
-        }, width, height, theme);
-      }
-      case "metrics": {
-        const { records, groups, taskTimes, stats, jev } = this.metricsFigures(query);
-        this.metricsSelected = Math.min(this.metricsSelected, Math.max(0, groups.length - 1));
-        return renderMetrics({ groups, taskTimes, records, stats, by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
-      }
-    }
-  }
-
-  /** The roster: the oracle chairing, then every domain seat in order, seated or not. */
-  private seatViews(session: PlanningSession | undefined): SeatView[] {
-    const seats = session?.seats ?? this.seatSet();
-    const oracleQuestions = session?.questions.filter((question) => question.from === ORACLE_LABEL).length ?? 0;
-    // While the seats work the oracle waits for them; its own part fails only when the round reports an error.
-    const status: SeatView["status"] = !session || session.turns === 0 ? "idle" : session.busy ? "thinking" : session.error ? "failed" : "done";
-    const oracle: SeatView = {
-      label: ORACLE_LABEL,
-      seated: true,
-      status,
-      ...(session?.busy && session.step ? { step: session.step } : {}),
-      questions: oracleQuestions,
-      ready: session?.reply?.status === "ready",
-      profile: this.host.profileLabel("planner"),
-    };
-    const members = PANEL_MEMBERS.map((member): SeatView => {
-      const state = session?.members.find((entry) => entry.member === member);
-      return {
-        label: MEMBER_LABELS[member],
-        seated: seats.has(member),
-        status: state ? (state.status === "thinking" ? "thinking" : state.status) : "idle",
-        ...(state?.step ? { step: state.step } : {}),
-        // The questions from this seat that reached the user this round.
-        questions: session?.questions.filter((question) => question.from === MEMBER_LABELS[member]).length ?? 0,
-        ready: state?.reply?.status === "ready",
-        profile: this.host.seatLabel(member),
-        ...(!state && session?.satOut.has(member) ? { satOut: session.satOut.get(member)! } : {}),
-        ...(session?.pins.has(member) ? { pinned: true } : {}),
-      };
-    });
-    return [oracle, ...members];
-  }
-
-  private planView(session: PlanningSession): PlanView {
-    return {
-      messages: session.messages,
-      ...(session.reply ? { reply: session.reply } : {}),
-      questions: session.questions,
-      notes: session.notes,
-      seats: this.seatViews(session),
-      busy: session.busy,
-      ...(session.step ? { step: session.step } : {}),
-      ...(session.error ? { error: session.error } : {}),
-      turns: session.turns,
-      limit: session.limit,
-      nextMode: session.nextMode,
-      ...(session.seed ? { seed: session.seed } : {}),
-      ...(session.saved ? { saved: session.saved } : {}),
-      ...(session.savedParts.length > 1 ? { savedParts: session.savedParts.length } : {}),
-      ...(session.title ? { title: session.title } : {}),
-      awaitingAnswers: session.awaitingAnswers,
-      answeredChunks: session.answered.length,
-      lineComments: session.lineComments,
-    };
-  }
-
-  /**
-   * The session browser: every session this window can show, grouped by
-   * where it runs, with a preview of the one picked — its task, what it is
-   * doing and the last of its conversation.
-   */
-  private pickerBody(width: number, height: number, theme: LobbyTheme): string[] {
-    const entries = this.sessionEntries();
-    this.pickIndex = Math.min(this.pickIndex, Math.max(0, entries.length - 1));
-    const wide = width >= 90;
-    const listWidth = wide ? Math.max(38, Math.round((width - 1) * 0.42)) : width;
-    const inner = listWidth - 4;
-    const lines: string[] = [];
-    let selectedLine = 0;
-    let section: SessionWhere | undefined;
-    const counts = new Map<SessionWhere, number>();
-    for (const entry of entries) counts.set(entry.where, (counts.get(entry.where) ?? 0) + 1);
-    entries.forEach((entry, index) => {
-      if (entry.where !== section) {
-        section = entry.where;
-        if (lines.length > 0) lines.push("");
-        lines.push(rule(inner, SECTION_OF[section], theme, String(counts.get(section) ?? 0)));
-      }
-      const selected = index === this.pickIndex;
-      if (selected) selectedLine = lines.length;
-      const mark = paint(theme, entry.where === "this window" ? "accent" : entry.where === "not running" ? "dim" : "toolTitle", WHERE_MARKS[entry.where]);
-      const name = selected ? bold(theme, entry.name) : entry.where === "not running" ? paint(theme, "muted", entry.name) : entry.name;
-      const status = paint(theme, entry.status === "working" ? "accent" : entry.status === "ended" || entry.status === "no task" ? "dim" : "muted", entry.status.replace(/_/g, " "));
-      const badges = [entry.auto ? paint(theme, "success", "⟳") : "", entry.waiting > 0 ? paint(theme, "warning", `● ${entry.waiting}`) : ""].filter(Boolean).join(" ");
-      const head = `${selected ? paint(theme, "accent", "▸") : " "} ${mark} ${name}`;
-      lines.push(selectRow(theme, spread(head, `${status}${badges ? ` ${badges}` : ""}`, inner), inner, selected, true));
-    });
-    const rows = Math.max(0, height - 2);
-    const start = windowStart(selectedLine, lines.length, rows);
-    const list = box(listWidth, height, lines.slice(start), { title: "Sessions", right: `${entries.length}`, focused: true, scroll: { total: lines.length, start }, theme });
-    if (!wide) return list;
-    const previewWidth = width - 1 - listWidth;
-    const picked = entries[this.pickIndex];
-    const preview = picked ? this.sessionPreview(picked, previewWidth - 4, rows, theme) : [];
-    return beside([list, box(previewWidth, height, preview, { title: "Preview", theme })]);
-  }
-
-  /** What the browser shows of one session: who and where, its task, what `enter` and `s` do, then the end of its conversation. */
-  private sessionPreview(entry: SessionEntry, width: number, height: number, theme: LobbyTheme): string[] {
-    const dot = paint(theme, "dim", " · ");
-    const task = entry.task;
-    const lines = [
-      ...wrapHanging(`${paint(theme, entry.where === "this window" ? "accent" : "toolTitle", WHERE_MARKS[entry.where])} `, bold(theme, entry.name), width),
-      ...wrapHanging("  ", [paint(theme, "muted", entry.where), paint(theme, entry.status === "working" ? "accent" : "muted", entry.status.replace(/_/g, " ")), entry.pid ? paint(theme, "dim", `pid ${entry.pid}`) : ""].filter(Boolean).join(dot), width),
-    ];
-    if (task) {
-      const progress = taskProgress(task);
-      lines.push(...wrapHanging("  ", [paint(theme, "dim", task.id), progress ? `${pips(progress.done, progress.total, Math.min(progress.total, 8), theme)} ${paint(theme, "muted", `${progress.done}/${progress.total}`)}` : ""].filter(Boolean).join(dot), width));
-    }
-    const flags = [entry.auto ? paint(theme, "success", "⟳ auto mode") : "", entry.waiting > 0 ? paint(theme, "warning", `● ${entry.waiting} question${entry.waiting === 1 ? "" : "s"} waiting for you`) : ""].filter(Boolean);
-    if (flags.length > 0) lines.push(...wrapHanging("  ", flags.join(dot), width));
-    const key = (text: string) => paint(theme, "accent", text);
-    const does: Record<SessionWhere, string> = {
-      "this window": `${key("enter")} ${paint(theme, "muted", "back to this window")}`,
-      background: `${key("enter")} ${paint(theme, "muted", "view it")}   ${key("s")} ${paint(theme, "muted", "move it into this window")}   ${key("x x")} ${paint(theme, "muted", "stop it")}`,
-      "other terminal": `${key("enter")} ${paint(theme, "muted", "view it and message it")}   ${paint(theme, "dim", "switch in its own terminal")}`,
-      "not running": `${key("enter")} ${paint(theme, "muted", "view it")}   ${key("s")} ${paint(theme, "muted", entry.sessionId ? "resume it in this window" : "take it over in this window")}`,
-    };
-    lines.push("", ...wrapHanging("  ", does[entry.where], width));
-    const chat = this.previewChat(entry);
-    const room = height - lines.length - 2;
-    if (room > 2) {
-      lines.push("", rule(width, "Conversation", theme));
-      const talk = chat.length > 0 ? chatTail(chat, width, theme, room - 1).lines : [paint(theme, "dim", "Nothing said yet.")];
-      lines.push(...talk.slice(-(room - 1)));
-    }
-    return lines;
-  }
-
-  /** The conversation behind an entry: this window's feed, a background session's, or a saved session file. */
-  private previewChat(entry: SessionEntry): readonly ChatEntry[] {
-    if (entry.view.kind === "here") return this.host.feed.chat;
-    if (entry.view.kind === "background") return this.viewedSessionFor(entry.view.key)?.feed.chat ?? [];
-    return entry.sessionId ? this.host.sessionChat(entry.sessionId) : [];
-  }
-
-  private viewedSessionFor(key: string): BackgroundSession | undefined {
-    return this.host.sessions().find((session) => session.key === key);
-  }
-
-  private homeBody(width: number, height: number, theme: LobbyTheme, now: number): string[] {
-    const zen = this.host.zen();
-    const feed = this.host.feed;
-    const sessionId = this.host.sessionId();
-    const others = this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && task.ownerSessionId !== sessionId).length;
-    const query = this.query();
-    const entry = this.viewedEntry();
-    if (entry.view.kind !== "here") return this.otherSessionBody(entry, width, height, theme, now);
-    const talk = this.conversationFor(entry);
-    return renderHome({
-      ...(zen.task ? { task: zen.task } : {}),
-      chat: talk.chat,
-      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
-      ...(feed.reply ? { liveReply: feed.reply } : {}),
-      activity: feed.activity,
-      thoughts: feed.thoughts,
-      busy: this.host.masterBusy(),
-      others,
-      pending: this.data.plans.filter((plan) => plan.status === "pending").length,
-      offsets: this.homeOffsets,
-      anchors: this.marks,
-      ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
-      panes: this.panes,
-      tick: this.tick,
-      now,
-      panels: this.panels,
-      ...(query ? { query } : {}),
-      keys: {
-        conversation: keyLabel(this.keys.toggleConversation),
-        activity: keyLabel(this.keys.toggleActivity),
-        thinking: keyLabel(this.keys.toggleThinking),
-      },
-    }, width, height, theme);
-  }
-
-  /**
-   * Another session on the Lobby tab: a background session's live feed, or an
-   * other terminal's conversation read from its session file.
-   */
-  private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
-    const session = this.viewedSession();
-    const talk = this.conversationFor(entry);
-    const task = entry.task;
-    const query = this.query();
-    const common = {
-      ...(task ? { task } : {}),
-      others: 0,
-      pending: 0,
-      offsets: this.homeOffsets,
-      anchors: this.marks,
-      ...(this.mode === "browse" ? { focus: this.homeFocus } : {}),
-      panes: this.panes,
-      tick: this.tick,
-      now,
-      panels: this.panels,
-      ...(query ? { query } : {}),
-      title: entry.name,
-      keys: {
-        conversation: keyLabel(this.keys.toggleConversation),
-        activity: keyLabel(this.keys.toggleActivity),
-        thinking: keyLabel(this.keys.toggleThinking),
-      },
-    };
-    if (session) {
-      const emptyNote = session.status === "starting" ? `starting ${session.name}…` : !session.alive ? `${session.name} has ended.` : `${session.name} has not said anything yet.`;
-      return renderHome({
-        ...common,
-        chat: talk.chat,
-        ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
-        ...(session.feed.reply ? { liveReply: session.feed.reply } : {}),
-        activity: session.feed.activity,
-        thoughts: session.feed.thoughts,
-        busy: session.busy,
-        emptyNote,
-      }, width, height, theme);
-    }
-    const running = entry.where === "other terminal";
-    return renderHome({
-      ...common,
-      chat: talk.chat,
-      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
-      activity: [],
-      thoughts: [],
-      busy: false,
-      emptyNote: running ? "Nothing said in this session yet." : entry.sessionId ? "Nothing was said in its session." : "No session has driven this task yet.",
-      activityNote: running
-        ? "This session runs in another terminal: its conversation shows here and your messages reach its oracle within seconds, but live activity only streams from sessions started in this window."
-        : `No session is running this task. Press esc, then s to ${entry.sessionId ? "resume it" : "take it over"} in this window; a message you send now waits until a session picks it up.`,
-    }, width, height, theme);
-  }
-
-  private tasksBody(width: number, height: number, theme: LobbyTheme, now: number): string[] {
-    const rows = this.taskRowList();
-    this.tasksSelected = Math.min(this.tasksSelected, Math.max(0, rows.length - 1));
-    const row = rows[this.tasksSelected];
-    const detailWidth = tasksWidths(width).detail - 4;
-    let detail: string[] = [];
-    if (row?.kind === "task") {
-      const task = this.data.tasks.find((entry) => entry.id === row.id);
-      if (task) detail = taskDetailLines(task, this.data.comments.get(task.id) ?? [], this.host.sessionId(), detailWidth, now, theme);
-    } else if (row?.kind === "plan") {
-      const plan = this.data.plans.find((entry) => entry.id === row.id);
-      if (plan) detail = planDetailLines(plan, detailWidth, now, theme);
-    } else if (row?.kind === "archived") {
-      const task = this.data.archived.find((entry) => entry.id === row.id);
-      const key = (text: string) => paint(theme, "accent", text);
-      if (task) {
-        detail = [
-          ...taskDetailLines(task, [], this.host.sessionId(), detailWidth, now, theme).slice(0, 3),
-          ...wrapHanging("  ", paint(theme, "warning", `archived ${row.age === "now" ? "just now" : `${row.age} ago`}`), detailWidth),
-          "",
-          ...wrapHanging("  ", `${key("a")} ${paint(theme, "muted", "restore it to the list")}   ${key("d d")} ${paint(theme, "muted", "delete it for good")}`, detailWidth),
-          ...taskDetailLines(task, [], this.host.sessionId(), detailWidth, now, theme).slice(3),
-        ];
-      }
-    }
-    const query = this.query();
-    return renderTasks({ rows, selected: this.tasksSelected, detail, focus: this.tasksFocus, detailOffset: this.tasksDetailOffset, ...(query ? { query } : {}), panes: this.panes }, width, height, theme);
-  }
-
-  render(width: number): string[] {
-    const theme = this.host.theme();
-    const rows = Math.max(1, this.host.rows());
-    const top = [this.tabBar(width, theme)];
-    const prompt = this.promptLines(width, theme);
-    const search = this.searchLines(width, theme);
-    const hint = this.hintLine(width, theme);
-    const bodyHeight = Math.max(0, rows - top.length - search.length - prompt.length - 1);
-    this.bodyTop = top.length;
-    this.promptTop = top.length + bodyHeight + search.length;
-    let body = this.help ? this.helpBody(width, bodyHeight, theme) : this.picking ? this.pickerBody(width, bodyHeight, theme) : this.body(width, bodyHeight, theme);
-    // A pane scrolled back that gained lines moves with them, so it keeps showing what was being read.
-    if (!this.help && !this.picking && this.clampScroll()) body = this.body(width, bodyHeight, theme);
-    const query = this.query();
-    if (query && !this.help) body = body.map((line) => highlight(line, query));
-    return [...top, ...body, ...search, ...prompt, hint].slice(0, rows).map((line) => fit(line, width));
-  }
-
-  invalidate(): void {
-    this.editor.invalidate();
-    this.search.invalidate();
-  }
-}