@a-t-h-i/bot-lobby 0.5.0 → 0.5.1

package/README.md

@@ -67,14 +67,17 @@ recorded in the task.
 pi install npm:@juicesharp/rpiv-ask-user-question
 ```
 
-It is optional. Without it `clarify` still works through Pi's built-in
-`select`/`input` prompts (or the Master asks in plain text), just with less
-structure.
+It is optional for the Master. Without it `clarify` still works through Pi's
+built-in `select`/`input` prompts (or the Master asks in plain text), just with
+less structure. The lobby's planning panel uses the same questionnaire on its
+own — the library ships as a bot-lobby dependency, so the panel's questions
+arrive one at a time with options whether or not you install the tool for the
+Master (see [The lobby](#the-lobby)).
 
 ## Usage
 
 ```
-/bot-lobby                      Open the lobby (alt+l): tasks, planning, quick fixes, issues, metrics
+/bot-lobby                      Open the lobby (alt+l): tasks, planning, quick fixes, metrics
 /bot-lobby <request>            Start a task and hand it to the Master
 /bot-lobby status [taskId]      Active task, state, approvals, blockers, legal next states
 /bot-lobby tasks                Task list (plus any unreadable task state)
@@ -96,26 +99,27 @@ structure.
 ## The lobby
 
 The lobby is bot-lobby's full-screen home: a tabbed view over every task in the
-project, your planning, quick fixes, GitHub issues and model performance, with
-one prompt at the bottom whose target follows the tab. It opens by itself when
+project, your planning, quick fixes and model performance, with one prompt at
+the bottom whose target follows the tab. It opens by itself when
 this session starts (or resumes) a task — the small zen widget returns whenever
 you hide it — and `alt+l` or `/bot-lobby` opens and hides it at any time, with
 or without a task.
 
 ```
- ◆ bot-lobby │ 1 Lobby  2 Tasks 2  3 Plan  4 Quick fix ⠋  5 Issues  6 Metrics        ⠋ TASK-add-login implementing
- ───────────────────────────────────────────────────────────────────────────────────────────────────────────
+ ◆ bot-lobby │ 1 Lobby  2 Tasks 2  3 Plan 2?  4 Quick fix ⠋  5 Metrics      ⠋ TASK-add-login implementing  Alt+H keys
                     (the zen scene: the oracle, DEV · DESIGN · RESEARCH · QA, the plan checklist)
- ── Conversation · TASK-add-login ──────────────────── ┬ ── Activity ───────────────────────────────────────
- you ▸ add a login page with email + password           │ 12:04 MASTER    ✓ scouting designer, backend
- oracle ▸ Proposal:                                     │ 12:06 DEV       ⠋ reading auth.ts…
-          - LoginForm component                         │ 12:06 DESIGN    ⠋ editing LoginForm.tsx…
-          - POST /api/login with rate limiting          │ 12:06 QUICK FIX ✓ done: rename getUser
- ── Thinking ───────────────────────────────────────────────────────────────────────── DEV · 12s ago ──
- The auth module already exposes a session helper; reuse it rather than adding a new one.
- ── message the oracle ─────────────────────────────────────────────────────────────────────────────────
+╭ Conversation · TASK-add-login ─────────────── Alt+C ╮ ╭ Activity ──────────────────────────────── Alt+A ╮
+│ you ▸ add a login page with email + password         │ │ 12:04 MASTER    ✓ scouting designer, backend    │
+│ oracle ▸ Proposal                                    │ │ 12:06 DEV       ⠋ reading auth.ts…              │
+│          • LoginForm component                       │ │ 12:06 DESIGN    ⠋ editing LoginForm.tsx…        │
+│          • POST /api/login with rate limiting        │ │ 12:06 QUICK FIX ✓ done: rename getUser          │
+╰──────────────────────────────────────────────────────╯ ╰─────────────────────────────────────────────────╯
+╭ Thinking ────────────────────────────────────────────────────────────────────────────────── DEV · 12s ago ╮
+│ The auth module already exposes a session helper; reuse it rather than adding a new one.                  │
+╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+ ── message the oracle ───────────────────────────────────────────────────────────────────────────────────────
   _
- TYPE  enter send · shift+enter newline · esc browse · tab next tab · alt+l hide lobby
+  TYPE  enter send  shift+enter newline  esc browse  tab next tab  alt+h keys  alt+l hide
 ```
 
 - **1 Lobby** — the task's zen scene, then the conversation with the oracle
@@ -126,7 +130,12 @@ or without a task.
   thoughts show up: the oracle's live thought as it streams, and each finished
   thought from a subagent, quick fix or the planner (pi's own transcript,
   behind the lobby, still carries the oracle's thinking blocks; `ctrl+t`
-  collapses them there). The prompt talks to the
+  collapses them there). The oracle's replies render as Markdown. Every pane
+  can be hidden and brought back — `alt+z` the scene, `alt+c` the
+  conversation, `alt+a` the activity log, `alt+k` thinking — and the rest take
+  its room; the choice is remembered (`lobby.panels`). Each pane scrolls on
+  its own (see **Scrolling** below), and a pane scrolled back stays on what
+  you are reading while new lines arrive. The prompt talks to the
   oracle (while it works, enter steers the running turn; `esc` stops it); with
   no task, it starts one.
 - **2 Tasks** — every task in the project: this session's, the ones other pi
@@ -145,41 +154,105 @@ or without a task.
   chairs on the Planner model: it reads the seats' questions and notes, folds
   every answer into the draft plan (with a *Decisions by domain* section) and
   asks only what no single seat owns. Each round the seats run in parallel,
-  read-only, then the oracle; the questions arrive numbered and attributed
-  (`3. QA  Which browsers must pass?`), you answer them all in one message,
-  and every seat reads every answer the next round — so the agents that later
-  build the task start aligned. A roster shows what each seat is doing and
-  whether it is READY; the plan is READY only when every seat and the oracle
-  agree, and the draft pane lists what each seat said the plan must respect.
-  While browsing, `1`–`4` seat or unseat DEV, DESIGN, QA and RESEARCH for the
-  next round, `enter` switches between the conversation and the draft, `s`
-  saves the plan to the pending tasks list, `n` starts over, `r` retries a
-  round that failed or lost a seat, and `x` stops one.
+  read-only, then the oracle. Every question comes with two to four options,
+  the seat's recommendation first, and the oracle puts them to you **one at a
+  time** through the ask-user-question questionnaire: a tab per question
+  labelled with the seat that asked it (`QA`, `DEV`…), its options with what
+  each means, and a row to type your own answer or add a note (four questions
+  per questionnaire; more follow in the next one). It opens by itself when a
+  round ends while the Plan tab is showing (`lobby.autoAsk`), and otherwise
+  when you press `enter` on the empty prompt or `a` while browsing; `esc` puts
+  it away with your answers so far kept, and `enter` resumes. Your answers go
+  back attributed (`3. [QA] Which browsers must pass? → evergreen only`), and
+  every seat reads every answer the next round — so the agents that later
+  build the task start aligned. You can still type a free reply instead.
+  Without the library the same questions come through pi's own select and
+  input dialogs. A roster shows what each seat is doing and whether it is
+  READY; the plan is READY only when every seat and the oracle agree. The
+  draft plan renders as Markdown (headings, lists, code, tables) beside the
+  conversation, followed by what each seat said the plan must respect.
+  **Comment on any line of the draft**: click it, or press `enter` to move to
+  the draft, pick a line with `↑↓` and press `c`, then type the comment. The
+  line is marked `◆` with your comment beneath it, and the comment goes to the
+  panel with your answers — or starts a round by itself when no question is
+  open. While browsing, `1`–`4` seat or unseat DEV, DESIGN, QA and RESEARCH
+  for the next round, `s` saves the plan to the pending tasks list, `n` starts
+  over, `r` retries a round that failed or lost a seat, `x` stops one, and `m`
+  opens the oracle's (Planner) settings.
 - **4 Quick fix** — a direct prompt, the way you would ask pi, that skips the
   whole workflow: one coding agent (full tools) makes the change right away
   while any task keeps running. Quick fixes run one at a time in the order you
   send them; each shows its steps and final report, and `x` cancels one. A
   request that turns out to be large is reported back instead of attempted.
-- **5 Issues** — the repository's open GitHub issues through the `gh` CLI (it
-  owns sign-in; bot-lobby stores no token). `enter` reads one with its
-  comments, `n` files a new one (first line is the title), `r` refreshes, and
-  `p` plans it: the Plan tab opens seeded with the issue, and the saved plan
-  keeps a link to it, so an issue becomes a task only after it has been
-  planned.
-- **6 Metrics** — model performance across every Master turn, subagent run,
-  quick fix, planning seat and oracle planning turn: per model and thinking level, the number of runs,
-  success rate, mean/median/p90 time, turns, tools, tokens, output tokens per
-  second and cost (columns drop from the right on narrow terminals); how long a
-  task takes from request to done by the oracle's model and thinking level; and
-  where the time goes by agent. `g` splits the table by agent, `s` cycles the
-  sort (runs, average time, success, cost).
+  `m` opens the quick fix agent's settings — model, thinking level, time
+  limit and instructions — right there (the same entry as in
+  `/bot-lobby settings`); the tab shows what it runs on.
+- **5 Metrics** — model performance across every Master turn, subagent run,
+  quick fix, planning seat and oracle planning turn, as a dashboard: tiles for
+  runs (with a sparkline of recent run times), success rate, average and p90
+  run time, cost and tasks; average run time per model and thinking level as
+  bars; success rate per model as meters marked `✓` (≥90%), `!` (≥70%) or `✗`;
+  where the time goes as one bar split by agent, with a legend, and how long a
+  task takes from request to done by the oracle's model; then the full table —
+  runs, success, mean/median/p90 time, turns, tools, tokens, output tokens per
+  second and cost (columns drop from the right on narrow terminals). `g`
+  splits the table by agent, `s` cycles the sort (runs, average time, success,
+  cost).
+
+The **Issues** tab (GitHub issues through the `gh` CLI, planned into tasks
+through the Plan tab) is switched off for now; `"lobby": { "issues": true }`
+brings it back as tab 5.
 
 **Keys.** Like a modal editor, the lobby has a typing mode (keys go to the
 prompt) and a browsing mode (`esc`; arrows move through lists, single keys run
 the tab's commands, and on Lobby, Plan and Quick fix any other key resumes
-typing). Everywhere: `tab`/`shift+tab` or `alt+1`…`alt+6` switch tabs,
-`pageup`/`pagedown` scroll, `ctrl+c` clears the prompt (or hides the lobby
-when it is empty) and `alt+l` hides the lobby. Anything that needs pi itself —
+typing). These work in both modes:
+
+| Key | Does |
+| --- | --- |
+| `alt+l` | hide the lobby (back to pi) |
+| `alt+h` (or `?` while browsing) | show every key, and the current tab's |
+| `alt+s` | bot-lobby settings: every agent's model, thinking and time limit, and the lobby's switches |
+| `ctrl+f` (or `/` while browsing) | search the current tab |
+| `tab` / `shift+tab`, `alt+1`…`alt+5` | switch tabs |
+| `alt+z` / `alt+c` / `alt+a` / `alt+k` | show or hide the zen scene / conversation / activity log / thinking |
+| `pageup` / `pagedown` | scroll the focused pane a page |
+| `ctrl+c` | clear the prompt, or hide the lobby when it is empty |
+
+Every shortcut can be rebound under `lobby.keys` in the config, by action name:
+`hide`, `help`, `settings`, `search`, `nextTab`, `prevTab`, `toggleScene`,
+`toggleConversation`, `toggleActivity`, `toggleThinking`, `scrollUp`,
+`scrollDown` — e.g. `"keys": { "toggleThinking": "alt+t" }`. Pick keys that
+never type a character (`alt+…`, `ctrl+…`, `f1`…).
+
+**Scrolling.** Every pane scrolls on its own and shows a scrollbar in its
+right border when it holds more than fits. While browsing, `←`/`→` move
+between the tab's panes (the conversation, activity log and thinking on
+Lobby; the conversation and draft on Plan; the list and detail on Tasks and
+Quick fix) and the focused one lights up; `↑`/`↓` scroll it a line (or move
+a list's selection, or the draft's cursor), `pageup`/`pagedown` a page, and
+`home`/`end` jump to its oldest line or back to its newest. The conversation,
+activity log and thinking are newest-last: scrolled back, a pane shows `↓N`
+for the lines below it and holds still while new ones arrive; `end` follows
+the newest again. Details stop at their last line. The Thinking pane keeps
+every recent thought, so earlier ones are a scroll away.
+
+**Search.** `ctrl+f` opens a search bar above the prompt; as you type, the tab
+narrows to what matches and every match is highlighted: the conversation,
+activity log and thoughts on Lobby; tasks and plans (by id, title, request,
+proposal or plan) on Tasks; the conversation on Plan (the draft stays whole,
+highlighted); jobs on Quick fix; runs (by agent, model, thinking level, kind or
+task) on Metrics. `enter` keeps the search while you browse the results,
+`esc` clears it, and each tab keeps its own.
+
+**Mouse.** Clicking a tab opens it, clicking a pane gives it the keys,
+clicking a draft plan line comments on it, clicking the prompt starts typing,
+and the wheel scrolls whichever pane is under the pointer. In pi's regular
+screen the lobby turns mouse reporting on only while it is showing (hold
+`shift` to select text with the mouse); in full-screen pi, pi reports the
+mouse itself. `"lobby": { "mouse": false }` turns clicks off.
+
+Anything that needs pi itself —
 built-in slash commands, `/model`, the tool-row toggle — works with the lobby
 hidden; bot-lobby's own `/bot-lobby …` commands also work from the Lobby
 prompt. When the Master asks you something (an approval, a clarifying
@@ -446,7 +519,7 @@ top-level `/bot-lobby-settings`) and persist globally to
   "researcher": { "model": "anthropic/claude-sonnet-5", "thinking": "low", "instructions": "", "timeoutMs": 600000 },
   "quickFix": { "model": "anthropic/claude-sonnet-5", "thinking": "low", "instructions": "", "timeoutMs": 600000 },
   "planner": { "model": "anthropic/claude-sonnet-5", "thinking": "high", "instructions": "", "timeoutMs": 300000 },
-  "lobby": { "autoOpen": true, "planningPanel": ["backend", "designer", "qa", "researcher"] },
+  "lobby": { "autoOpen": true, "planningPanel": ["backend", "designer", "qa", "researcher"], "autoAsk": true, "issues": false, "mouse": true },
   "workflow": {
     "maxReviewIterations": 2,
     "maxParallelScouts": 3,
@@ -489,10 +562,29 @@ take custom instructions, and run on the session's model until you pin one.
 Planning seats reuse their domain's entry — DEV the Backend's, DESIGN the
 Designer's, QA the QA's, RESEARCH the Researcher's model, thinking and
 instructions — so a seat plans on the model that will later build its part.
-`lobby.planningPanel` names the seats a new planning session starts with
-(every seat by default; `[]` lets the oracle plan alone), and
-`lobby.autoOpen` (default `true`) opens the lobby by itself when this session
-starts or resumes a task.
+The `lobby` entry shapes the lobby itself; `/bot-lobby settings` → **Lobby**
+flips its switches, and key rebinding lives in the file:
+
+```json
+"lobby": {
+  "autoOpen": true,
+  "planningPanel": ["backend", "designer", "qa", "researcher"],
+  "autoAsk": true,
+  "issues": false,
+  "mouse": true,
+  "panels": { "scene": true, "conversation": true, "activity": true, "thinking": true },
+  "keys": { "toggleThinking": "alt+t" }
+}
+```
+
+`planningPanel` names the seats a new planning session starts with (every
+seat by default; `[]` lets the oracle plan alone); `autoOpen` opens the lobby
+by itself when this session starts or resumes a task; `autoAsk` puts the
+panel's questions to you as soon as a round ends while the Plan tab is
+showing (otherwise `enter` on the empty prompt does); `issues` shows the
+GitHub Issues tab (off for now); `mouse` turns clicks and the wheel on;
+`panels` is which Lobby panes show (the pane keys update it); `keys` rebinds
+shortcuts by action name.
 
 `thinking` must be one of `off`, `minimal`, `low`, `medium`, `high`, `xhigh`,
 `max`; a legacy `inherit` or unknown value falls back to `medium`. The thinking
@@ -591,13 +683,16 @@ src/
 ├── prompts/                  Layer loader + compiler
 ├── lobby/
 │   ├── runtime.ts            Mounts the full-screen lobby on pi's TUI, dialogs hand-off, comment delivery, Master metrics
-│   ├── view.ts               The tabbed view: tab bar, per-tab prompt, typing/browsing modes, keys
+│   ├── view.ts               The tabbed view: tab bar, per-tab prompt, typing/browsing modes, search, help, mouse
+│   ├── keys.ts               The shortcut table and its config overrides
+│   ├── ask.ts                The panel's questions through the ask-user-question questionnaire (or pi's dialogs)
+│   ├── markdown.ts           Markdown through pi's renderer, cached per theme and width
 │   ├── tabs/                 Pure renderers: home, tasks, plan, quickfix, issues, metrics
 │   ├── feed.ts               Activity log, thinking pane and conversation store
 │   ├── quickfix.ts           Direct-change jobs, one at a time
 │   ├── planner.ts            The planning panel: seats and the oracle per round, reply parsing, saving a plan
 │   ├── issues.ts             GitHub issues through the gh CLI
-│   └── layout.ts             Exact-width columns, rules, wrapping and scroll windows
+│   └── layout.ts             Boxes, exact-width columns, wrapping, highlights, bars, meters and sparklines
 ├── state/                    Project root, config, task persistence, state mutation, comments, backlog, metrics
 ├── schemas/                  Task, agent, findings, configuration types
 └── pi/                       Commands, lifecycle, orchestrate tool, status widget

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -38,11 +38,14 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.87.0",
     "@earendil-works/pi-ai": "0.87.0",
+    "@earendil-works/pi-coding-agent": "0.87.0",
     "@earendil-works/pi-tui": "0.87.0",
     "@types/node": "^22.10.0",
     "typebox": "1.3.27",
     "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "@juicesharp/rpiv-ask-user-question": "^2.11.0"
   }
 }

package/prompts/panel.md

@@ -17,7 +17,9 @@ questions and the user's answers, and the oracle's current draft plan.
   task is built or verified. Never repeat a question that has been answered,
   or one another member already asked this round.
 - Ask at most two questions, the most important first. Make each specific and
-  answerable; offer options (`a) …  b) …`) and say which you would pick.
+  answerable, and give it two to four options the user can pick from, your
+  recommendation first with `(Recommended)` after its label. The user can
+  always type their own answer instead, so do not add an "Other" option.
 - If an answer from the user is vague or conflicts with what you see in the
   repository, say so and ask again.
 - Report what the plan must respect from your seat under Notes: facts from
@@ -31,9 +33,12 @@ questions and the user's answers, and the oracle's current draft plan.
 OPEN or READY
 
 ## Questions
-1. …
+1. The question, ending with a question mark?
+   - Short label (Recommended) — what choosing it means
+   - Another label — what choosing it means
 
-(Omit Questions when READY.)
+(Two to four options per question, labels of one to five words. Omit
+Questions when READY.)
 
 ## Notes
 - …

package/prompts/planner.md

@@ -23,8 +23,10 @@ below.
   only cross-cutting ones the members did not ask: scope and non-goals,
   priorities, trade-offs between domains, sequencing, rollout and rollback.
   Never repeat a member's question. Each one must be specific and answerable.
-- Offer concrete options when they help (`a) …  b) …`), and say which you
-  would pick and why.
+- Give every question two to four options the user can pick from, your
+  recommendation first with `(Recommended)` after its label. The user answers
+  the panel's questions one at a time and can always type their own answer,
+  so never add an "Other" option.
 - Challenge answers that are vague, contradictory or risky, and ask again.
   Do not accept "whatever you think" for a decision with real trade-offs:
   propose one and ask the user to confirm it.
@@ -44,10 +46,13 @@ GRILLING or READY
 Three to six words naming the task.
 
 ## Questions
-1. The most important open question.
+1. The most important open question?
+   - Short label (Recommended) — what choosing it means
+   - Another label — what choosing it means
 2. …
 
-(Omit the Questions section when READY.)
+(Two to four options per question, labels of one to five words. Omit the
+Questions section when READY.)
 
 ## Plan
 The current draft, in Markdown:

package/src/lobby/ask.ts

@@ -0,0 +1,226 @@
+/**
+ * The oracle puts the planning panel's questions to the user one at a time
+ * through the ask-user-question library (`@juicesharp/rpiv-ask-user-question`):
+ * a tabbed questionnaire with each seat's options, the recommended one first,
+ * and a free-text row on every question. The library only publishes a pi
+ * extension entry point, so its `ask_user_question` tool is captured by
+ * calling that entry with a `pi` whose `registerTool` keeps the definition
+ * instead of registering it; its `execute` then runs the real questionnaire.
+ * Without the library, pi's own select and input dialogs ask the same
+ * questions in the same order.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { PanelQuestion } from "./planner.ts";
+
+/** The library's limits: at most 4 questions per questionnaire, 2-4 options each. */
+export const MAX_QUESTIONS = 4;
+export const MIN_OPTIONS = 2;
+export const MAX_OPTIONS = 4;
+const MAX_HEADER = 16;
+const MAX_LABEL = 60;
+/** Labels the library reserves for its own rows. */
+const RESERVED = new Set(["other", "type something.", "next"]);
+
+export interface AskOption {
+  label: string;
+  description: string;
+}
+
+export interface AskQuestion {
+  question: string;
+  header: string;
+  options: AskOption[];
+  multiSelect?: boolean;
+}
+
+export interface AskAnswer {
+  questionIndex: number;
+  question: string;
+  kind: "option" | "custom" | "multi";
+  answer: string | null;
+  selected?: string[];
+  notes?: string;
+}
+
+export interface AskResult {
+  answers: AskAnswer[];
+  cancelled: boolean;
+  globalNote?: string;
+}
+
+/** Puts up to `MAX_QUESTIONS` questions to the user and returns what they chose. */
+export type Asker = (questions: readonly AskQuestion[], ctx: ExtensionContext) => Promise<AskResult>;
+
+interface ToolLike {
+  execute(toolCallId: string, params: unknown, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext): Promise<{ details?: unknown }>;
+}
+
+function clip(text: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/** Filler options for a question the panel asked without any. */
+const DEFAULT_OPTIONS: readonly AskOption[] = [
+  { label: "Go with the recommendation", description: "Let the panel pick the option it recommends." },
+  { label: "Leave it open", description: "Skip this one for now; the panel may ask again." },
+];
+
+/** A panel question in the library's schema: seat as the chip, 2-4 unique, unreserved option labels. */
+export function toAskQuestion(question: PanelQuestion): AskQuestion {
+  const seen = new Set<string>();
+  const options: AskOption[] = [];
+  for (const option of question.options) {
+    let label = clip(option.label, MAX_LABEL);
+    if (!label || RESERVED.has(label.toLowerCase())) continue;
+    for (let n = 2; seen.has(label.toLowerCase()); n++) label = clip(`${option.label} (${n})`, MAX_LABEL);
+    seen.add(label.toLowerCase());
+    options.push({ label, description: option.description.trim() || label });
+    if (options.length === MAX_OPTIONS) break;
+  }
+  for (const filler of DEFAULT_OPTIONS) {
+    if (options.length >= MIN_OPTIONS) break;
+    if (!seen.has(filler.label.toLowerCase())) options.push({ ...filler });
+  }
+  return { question: question.text.trim(), header: clip(question.from, MAX_HEADER), options };
+}
+
+/** Split the round's questions into questionnaires of at most `MAX_QUESTIONS`, with unique question texts. */
+export function questionnaires(questions: readonly PanelQuestion[]): AskQuestion[][] {
+  const seen = new Set<string>();
+  const asked = questions.map((question) => {
+    const ask = toAskQuestion(question);
+    let text = ask.question;
+    for (let n = 2; seen.has(text.toLowerCase()); n++) text = `${ask.question} (${question.from}${n > 2 ? ` ${n}` : ""})`;
+    seen.add(text.toLowerCase());
+    return { ...ask, question: text };
+  });
+  const chunks: AskQuestion[][] = [];
+  for (let i = 0; i < asked.length; i += MAX_QUESTIONS) chunks.push(asked.slice(i, i + MAX_QUESTIONS));
+  return chunks;
+}
+
+function answerText(answer: AskAnswer | undefined): string | undefined {
+  if (!answer) return undefined;
+  if (answer.kind === "multi") return answer.selected && answer.selected.length > 0 ? answer.selected.join(", ") : undefined;
+  return answer.answer?.trim() || undefined;
+}
+
+/**
+ * The user's turn for the next round: every question with who asked it and
+ * the answer (`→ …`), their notes, and what they left unanswered. Undefined
+ * when nothing was answered.
+ */
+export function answerMessage(questions: readonly PanelQuestion[], results: readonly AskResult[]): string | undefined {
+  const lines: string[] = [];
+  const skipped: string[] = [];
+  const notes: string[] = [];
+  let answered = 0;
+  results.forEach((result, chunk) => {
+    if (result.globalNote?.trim()) notes.push(result.globalNote.trim());
+    const offset = chunk * MAX_QUESTIONS;
+    for (let i = 0; i < MAX_QUESTIONS; i++) {
+      const question = questions[offset + i];
+      if (!question) break;
+      const answer = result.answers.find((entry) => entry.questionIndex === i);
+      const text = answerText(answer);
+      const label = `${offset + i + 1}. [${question.from}] ${question.text.replace(/\s+/g, " ").trim()}`;
+      if (!text) {
+        skipped.push(label);
+        continue;
+      }
+      answered += 1;
+      lines.push(`${label}\n   → ${text}${answer?.kind === "custom" ? " (in my words)" : ""}`);
+      if (answer?.notes?.trim()) lines.push(`   note: ${answer.notes.trim()}`);
+    }
+  });
+  if (answered === 0 && notes.length === 0) return undefined;
+  return [
+    "Answers to the panel's questions:",
+    ...lines,
+    ...(notes.length > 0 ? ["", `Note: ${notes.join(" ")}`] : []),
+    ...(skipped.length > 0 ? ["", "Not answered this round:", ...skipped] : []),
+  ].join("\n");
+}
+
+/**
+ * Capture the library's tool through its public extension entry: the entry
+ * registers the tool on the `pi` it is given, so a `pi` whose `registerTool`
+ * keeps the definition (and whose `on` ignores the library's own tool-list
+ * reconciler) yields it without touching the session's tools. Undefined when
+ * the library is missing or registers nothing.
+ */
+/**
+ * The library ships TypeScript sources; a non-literal specifier keeps them out
+ * of this package's typecheck (they are compiled by pi's loader at runtime).
+ */
+const ASK_LIBRARY: string = "@juicesharp/rpiv-ask-user-question";
+
+export async function loadAskTool(pi: ExtensionAPI, load: () => Promise<unknown> = () => import(ASK_LIBRARY)): Promise<ToolLike | undefined> {
+  try {
+    const module = (await load()) as { default?: (pi: ExtensionAPI) => void };
+    if (typeof module.default !== "function") return undefined;
+    let captured: ToolLike | undefined;
+    const capture = new Proxy(pi, {
+      get(target, property, receiver) {
+        if (property === "registerTool") return (tool: ToolLike & { name?: string }) => {
+          if (tool.name === "ask_user_question") captured = tool;
+        };
+        if (property === "on") return () => () => {};
+        return Reflect.get(target, property, receiver);
+      },
+    });
+    module.default(capture);
+    return captured;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Run one questionnaire through the captured tool. */
+export function toolAsker(tool: ToolLike): Asker {
+  return async (questions, ctx) => {
+    const result = await tool.execute(`bot-lobby-panel-${Date.now().toString(36)}`, { questions }, undefined, undefined, ctx);
+    const details = result.details as Partial<AskResult> | undefined;
+    return { answers: details?.answers ?? [], cancelled: details?.cancelled !== false, ...(details?.globalNote ? { globalNote: details.globalNote } : {}) };
+  };
+}
+
+const TYPE_ANSWER = "Type an answer…";
+const SKIP = "Skip";
+
+/** The same questions through pi's built-in dialogs: pick an option, type an answer, or skip; esc stops. */
+export function dialogAsker(): Asker {
+  return async (questions, ctx) => {
+    const answers: AskAnswer[] = [];
+    for (const [index, question] of questions.entries()) {
+      const choices = [...question.options.map((option) => option.label), TYPE_ANSWER, SKIP];
+      const title = `${question.header} · ${index + 1}/${questions.length}\n\n${question.question}`;
+      const choice = await ctx.ui.select(title, choices);
+      if (choice === undefined) return { answers, cancelled: true };
+      if (choice === SKIP) continue;
+      if (choice === TYPE_ANSWER) {
+        const typed = await ctx.ui.input(question.question, "your answer");
+        if (typed === undefined) return { answers, cancelled: true };
+        if (typed.trim()) answers.push({ questionIndex: index, question: question.question, kind: "custom", answer: typed.trim() });
+        continue;
+      }
+      answers.push({ questionIndex: index, question: question.question, kind: "option", answer: choice });
+    }
+    return { answers, cancelled: false };
+  };
+}
+
+/**
+ * Put every question to the user, one questionnaire after another. Stopping
+ * a questionnaire (esc) stops the rest; what was answered before it is kept.
+ */
+export async function askPanel(questions: readonly PanelQuestion[], ask: Asker, ctx: ExtensionContext): Promise<{ results: AskResult[]; stopped: boolean }> {
+  const results: AskResult[] = [];
+  for (const chunk of questionnaires(questions)) {
+    const result = await ask(chunk, ctx);
+    if (result.cancelled) return { results, stopped: true };
+    results.push(result);
+  }
+  return { results, stopped: false };
+}

package/src/lobby/keys.ts

@@ -0,0 +1,51 @@
+/**
+ * The lobby's shortcuts in one table: every action has a default key, a line
+ * for the help overlay, and can be rebound under `lobby.keys` in the config
+ * (`{ "toggleThinking": "alt+t" }`). They work in typing and browsing mode
+ * alike, so each default is a key that never types a character.
+ */
+import { matchesKey, type KeyId } from "@earendil-works/pi-tui";
+
+export const LOBBY_ACTIONS = {
+  hide: { key: "alt+l", help: "hide the lobby (back to pi)" },
+  help: { key: "alt+h", help: "show or hide these keys" },
+  settings: { key: "alt+s", help: "bot-lobby settings: each agent's model and thinking, the lobby" },
+  search: { key: "ctrl+f", help: "search the current tab" },
+  nextTab: { key: "tab", help: "next tab" },
+  prevTab: { key: "shift+tab", help: "previous tab" },
+  toggleScene: { key: "alt+z", help: "show or hide the zen scene" },
+  toggleConversation: { key: "alt+c", help: "show or hide the conversation" },
+  toggleActivity: { key: "alt+a", help: "show or hide the activity log" },
+  toggleThinking: { key: "alt+k", help: "show or hide thinking" },
+  scrollUp: { key: "pageUp", help: "scroll up a page" },
+  scrollDown: { key: "pageDown", help: "scroll down a page" },
+} as const;
+
+export type LobbyAction = keyof typeof LOBBY_ACTIONS;
+
+export type KeyMap = Record<LobbyAction, string>;
+
+/** Defaults with the config's overrides on top; unknown action names are ignored. */
+export function keyMap(overrides: Readonly<Record<string, string>> = {}): KeyMap {
+  const map = Object.fromEntries(Object.entries(LOBBY_ACTIONS).map(([action, entry]) => [action, entry.key])) as KeyMap;
+  for (const [action, key] of Object.entries(overrides)) {
+    if (action in map && key.trim()) map[action as LobbyAction] = key.trim().toLowerCase();
+  }
+  return map;
+}
+
+/** The action `data` triggers under `map`, if any. */
+export function actionFor(data: string, map: KeyMap): LobbyAction | undefined {
+  for (const action of Object.keys(map) as LobbyAction[]) {
+    if (matchesKey(data, map[action] as KeyId)) return action;
+  }
+  return undefined;
+}
+
+/** `alt+k` reads `Alt+K` in hints and help. */
+export function keyLabel(key: string): string {
+  return key
+    .split("+")
+    .map((part) => (part.length === 1 ? part.toUpperCase() : part[0]!.toUpperCase() + part.slice(1)))
+    .join("+");
+}