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

package/README.md

@@ -67,15 +67,19 @@ 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 each round's questions
+arrive together in one dialog 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 --task [--auto] <request>   Start a task even when the request begins with a subcommand word
 /bot-lobby status [taskId]      Active task, state, approvals, blockers, legal next states
 /bot-lobby tasks                Task list (plus any unreadable task state)
 /bot-lobby pause | resume       Stop or allow further workflow steps
@@ -90,51 +94,79 @@ structure.
 /bot-lobby-settings             Same as the settings subcommand
 /bot-lobby minimize|restore     Hide or restore bot-lobby for this session (ctrl+shift+m)
 /bot-lobby claim <taskId>      Take ownership of an orphaned task
+/bot-lobby auto [on|off]        Auto mode: the oracle drives this session's task to completion (alt+g)
+/bot-lobby start-plan PLAN-… [auto]   Start a saved plan here; its agreed plan needs no approval
 /bot-lobby lobby | help         Open the lobby, or show this list
 ```
 
 ## 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
- ───────────────────────────────────────────────────────────────────────────────────────────────────────────
-                    (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 ─────────────────────────────────────────────────────────────────────────────────
+ ◆ bot-lobby │ 1 Lobby  2 Tasks 2  3 Plan 2?  4 Quick fix ⠋  5 Metrics      ⠋ TASK-add-login implementing  Alt+H keys
+                    (the task's status: state, what the agents are doing, the plan checklist)
+╭ Conversation ──────────────────────────────── Alt+C ╮ ╭ Activity ──────────────────────────────── Alt+A ╮
+│ ──────── task started · add login · 12:04 ───────── │ │ 12:04 MASTER    ✓ scouting designer, backend    │
+│ ● You                                         12:04 │ │ 12:06 DEV       ⠋ reading auth.ts…              │
+│   ▌ add a login page with email + password          │ │ 12:06 DESIGN    ⠋ editing LoginForm.tsx…        │
+│ ◆ Oracle                                      12:06 │ │ 12:06 QUICK FIX ✓ done: rename getUser          │
+│   Proposal                                          │ │                                                 │
+│   • LoginForm component                             │ │                                                 │
+│   • POST /api/login with rate limiting              │ │                                                 │
+╰─────────────────────────────────────────────────────╯ ╰─────────────────────────────────────────────────╯
+╭ 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  esc browse  alt+l hide
 ```
 
-- **1 Lobby** — the task's zen scene, then the conversation with the oracle
-  (its text only: no tool rows, no thinking), an activity log that narrates
+- **1 Lobby** — the task's status (its state box, what the agents are
+  doing and the plan checklist), then the conversation with the oracle
+  (its text only: no tool rows, no thinking; each turn under a `● You` or
+  `◆ Oracle` line with its time, your words in pi's user-message band, the
+  oracle's replies as Markdown, and events such as a task starting as a
+  rule), an activity log that narrates
   every tool call in plain words (`reading index.html…`, `searching for
   "router" in src`, `running npm test`, `delegating to backend: Step 2 …`) from
   the Master and every subagent, and a single **Thinking** pane — the one place
   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. To keep
+  the lobby clean, the animated oracle and agents stay out of it by default:
+  they show above pi's editor while the lobby is hidden, and `alt+z` brings
+  them into the lobby too (the status box names the key in its corner). `alt+c`, `alt+a` and `alt+k` hide or bring back the conversation,
+  the activity log and thinking, and the rest take their room; every 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
-  sessions are driving, pending plans saved from the planner, and recently
-  finished ones. The detail pane shows the request, the approved plan with its
-  step checklist, your comments on it, amendments, what the task waits on and
-  its recent runs. `c` comments on the selected task's plan (see below), `s`
-  starts a pending plan as a task in this session, `d` twice discards one.
+- **2 Tasks** — every task in the project as a checklist: this session's, the
+  ones other pi sessions are driving, pending plans saved from the planner, and
+  recently finished ones, each section under a rule with its count. A task or
+  plan still to do wears an empty box `☐` (coloured by its state) with its
+  state, auto mode and owner beneath and its plan progress as pips
+  (`▰▰▱▱ 2/4`); a completed task is ticked `☑`, and an abandoned one is crossed
+  `☒` with its title struck through. The detail pane shows the task's box,
+  state and progress bar, then the request, the plan's steps (`☑` done, `☐`
+  to do, `◂ now` on the current one), the approved plan, your comments on it,
+  amendments, what the task waits on and its recent runs. `c` comments on the selected task's plan (see below), `s`
+  starts a pending plan as a task **in a new session** and `h` starts it
+  here, in this window (either way its agreed plan needs no approval), `d`
+  twice discards one. `n` types a new task that starts in its own session, `o`
+  shows the session driving the selected task, `x` twice stops a background
+  session, and `alt+g` switches auto mode for the selected task. Rows say who
+  drives each task (`this session`, `background`, another session's id) and
+  mark auto mode `⟳ auto`.
 - **3 Plan** — task planning mode with a planning panel. Describe what you
   want and every seat grills you from its own domain, on the model and
   thinking level its settings name: **DEV** (APIs, data, errors, security,
@@ -142,44 +174,116 @@ or without a task.
   accessibility), **QA** (acceptance criteria, test strategy, edge cases,
   definition of done) and **RESEARCH** (libraries, versions, docs and prior
   art, with the web tools when `pi-web-access` is installed). The **oracle**
-  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.
+  chairs on the Planner model: it reads the seats' questions and notes and
+  folds every answer into the draft plan (with a *Decisions by domain*
+  section). Each round the seats run in parallel, read-only, then the oracle,
+  which **chooses at most four questions** for you from the seats' and its own
+  — merged, in plain words, the most decisive first — and decides the rest
+  with the recommended option, listed under *Assumptions* in the draft so you
+  can see and overrule them (comment on the line). The round's questions come
+  in **one** ask-user-question dialog: a tab per question labelled with the
+  seat it serves (`QA`, `DEV`…), two to four options with what each means,
+  the recommendation first (so `enter` on each accepts it), a row to type your
+  own answer or add a note, and a Submit tab that reviews everything and lets
+  you leave a question blank (the oracle then takes its recommendation). 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, `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 |
+| `ctrl+s` | save the plan from the Plan tab to the pending tasks — while typing too, from any tab |
+| `alt+o` | the session switcher: this window, its background sessions, and tasks other terminals drive |
+| `alt+n` | type a new task that starts in its own session, named after it |
+| `alt+g` | auto mode on or off for the task in view (the selected one on Tasks) |
+| `tab` / `shift+tab`, `alt+1`…`alt+5` | switch tabs |
+| `alt+z` | show or hide the oracle and agent animations in the lobby (off by default; the task's status always shows) |
+| `alt+c` / `alt+a` / `alt+k` | show or hide the 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`, `savePlan`, `sessions`, `newSession`,
+`toggleAuto`, `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
@@ -195,6 +299,70 @@ approved plan while implementing or reviewing, keeps finished steps done and
 marks the comments addressed (`○` waiting, `◐` sent to the oracle, `✓` plan
 amended). Before a plan exists, a comment asks for a revised proposal instead.
 
+## Several sessions from one window
+
+Start a task in a new session without leaving your terminal, and switch
+between sessions from the lobby.
+
+- **Start one.** `alt+n` (or `n` on the Tasks tab) opens the prompt for a new
+  task; `enter` starts it in its own pi session. `s` on a saved plan does the
+  same for the plan. The new session is a headless pi (`pi --mode rpc`) this
+  window launches with the same pi build, model and extensions, and it is an
+  ordinary saved session **named after its task** — `/resume` lists it by
+  that name. Sessions a task starts are named after it too (`/bot-lobby
+  <request>` in a fresh session names that session).
+- **Watch and talk to it.** The Lobby tab then shows that session: its task's
+  status, its conversation, activity log and thoughts, live. The tab bar names
+  the session in view (`◆ add signup form · working`), the prompt messages
+  its oracle (steering it while it works) and `esc` stops its running turn.
+- **Answer it.** When a background session asks something — an approval, a
+  clarifying question — the tab bar shows `● 1 waiting`, and `enter` on the
+  empty prompt puts the question to you in this window with pi's own dialog
+  (`esc` there cancels it, as it would in that session). With the lobby
+  hidden, a notice says who is waiting.
+- **Switch.** `alt+o` opens the switcher: this window, every background
+  session it started (working, idle, ended; `⟳ auto`; questions waiting), and
+  tasks that sessions in other terminals drive. `enter` shows one in the Lobby
+  tab, `n` starts a new one, `x` twice stops a background session. For a task
+  another terminal drives, the Lobby shows its conversation from its session
+  file, and your messages go to its task inbox (`inbox.jsonl`) — its own
+  session passes them to its oracle within a few seconds — while its live
+  activity stays in that terminal.
+
+Background sessions belong to the window that started them: they keep running
+while you switch pi sessions there, and stop when that pi exits. Their tasks
+keep their state, so `/resume` (by the task's name) or `/bot-lobby claim`
+picks one up later.
+
+## Auto mode
+
+Auto mode lets the oracle drive a task to completion without asking you
+anything. Switch it with `alt+g` — in the lobby for the task in view (or the
+one selected on Tasks), outside it for this session's task — or with
+`/bot-lobby auto [on|off]`; `/bot-lobby --task --auto <request>` and
+`/bot-lobby start-plan PLAN-… auto` start a task with it on. The tab bar shows
+`⟳ AUTO`. While it is on:
+
+- clarifying questions are not asked: the oracle decides from the request,
+  the plan and its reconnaissance, and each decision is recorded
+  (`Not asked (auto mode): …`); the ask-user-question tool is blocked with the
+  same instruction;
+- the proposal is approved without asking, and dependency and architecture
+  approvals a worker asks for are granted and recorded;
+- when the oracle's turn ends before the task is done, the session nudges it
+  to keep going. A nudge that changes nothing counts; after three in a row
+  auto mode pauses and says the task needs you, and it resumes as soon as the
+  task moves again.
+
+The switch lives beside the task (`auto.json`), so any session can flip it for
+any task and the session that drives it follows within a few seconds.
+
+**Agreed plans skip approval.** A task started from a plan saved in the Plan
+tab (`s`/`h` on Tasks, or `/bot-lobby start-plan`) records the plan it came
+from, and its proposal is approved without asking you again — you agreed the
+plan with the panel already. Clarifying questions are still decided by the
+oracle for such a task, since the plan answered them.
+
 ## Sessions and ownership
 
 A task is owned by the pi session that started it (`ctx.sessionManager` id,
@@ -220,8 +388,8 @@ every in-flight subagent process.
 
 While the owning session has a task active, its transcript switches to a zen view: `orchestrate` rows
 and the built-in spinner are hidden, and a widget above the editor animates the
-task (the same scene heads the lobby's first tab; the widget shows while the
-lobby is hidden). At 72 columns and wider it draws a large scene: a header box with the task
+task (the widget shows while the lobby is hidden; inside the lobby the same
+scene shows only with `alt+z`, its status box otherwise). At 72 columns and wider it draws a large scene: a header box with the task
 title and state in its top border, a progress bar, and a metadata row with
 elapsed time, quiet-mode hint and task id; an oracle tower with a twinkling
 aura (drifting z's while dormant), a radiant orb crown, two window eyes, a
@@ -446,7 +614,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 +657,31 @@ 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": { "animations": false, "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, with `animations: true` bringing the
+animated oracle and agents into the lobby (off by default; the older
+`scene` key is no longer read, and 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
@@ -542,6 +731,8 @@ and the output contract — and an empty layer is dropped.
 └── tasks/TASK-<stamp>/
     ├── state.json              the task record (kept after completion)
     ├── comments.jsonl          your lobby comments on the plan and their delivery (append-only)
+    ├── inbox.jsonl             messages for the oracle from other sessions and their delivery (append-only)
+    ├── auto.json               auto mode, when switched on for the task
     ├── proposal.md             scratchpads: deleted on completion
     ├── plan.md
     ├── designer.md backend.md qa.md
@@ -590,17 +781,22 @@ src/
 ├── knowledge/                Paths, store (single write path), selector, compactor
 ├── 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
+│   ├── runtime.ts            Mounts the full-screen lobby on pi's TUI, dialogs hand-off, background sessions, Master metrics
+│   ├── view.ts               The tabbed view: tab bar, per-tab prompt, typing/browsing modes, session switcher, search, help, mouse
+│   ├── sessions.ts           Background sessions: headless pi children driven over RPC, their feeds and questions
+│   ├── session-files.ts      Other sessions' conversations, read from their saved session files
+│   ├── 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
-├── state/                    Project root, config, task persistence, state mutation, comments, backlog, metrics
+│   └── layout.ts             Boxes, exact-width columns, wrapping, highlights, bars, meters and sparklines
+├── state/                    Project root, config, task persistence, state mutation, comments, inbox, auto mode, backlog, metrics
 ├── schemas/                  Task, agent, findings, configuration types
-└── pi/                       Commands, lifecycle, orchestrate tool, status widget
+└── pi/                       Commands, lifecycle, orchestrate tool, status widget, the owner's clock (deliveries, auto mode)
 prompts/                      global, master, designer, backend, qa, scout, worker, reviewer, researcher, quickfix, planner, panel
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "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

@@ -16,8 +16,14 @@ questions and the user's answers, and the oracle's current draft plan.
 - Ask only what your seat owns (below), and only what would change how the
   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.
+- Ask at most two questions, the most important first. They go to the
+  oracle, who picks at most four for the user each round across the whole
+  panel and decides the rest with your recommendation, so make each one
+  short, plain and specific, and give it two to four options, your
+  recommendation first with `(Recommended)` after its label. The user can
+  always type their own answer instead, so do not add an "Other" option.
+- Read the draft's Assumptions: if one the oracle made for your seat is
+  wrong, say so under Notes and ask about it again.
 - 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 +37,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

@@ -3,9 +3,11 @@
 You are the oracle chairing a planning panel: you help the user turn an idea
 (or a GitHub issue) into a task plan that the team of agents can execute
 without guessing. The panel's domain members — DEV, DESIGN, QA and RESEARCH —
-ask the user their own questions each round; you own the plan and the
-questions no single domain owns. You are relentless: together you grill the
-user until every decision that changes the implementation is made. You never
+bring you their questions each round, and you decide which ones reach the
+user: you own the plan and the questions. You are thorough but you spare the
+user: every decision that changes the implementation gets made, either by the
+user or by you with the recommended option, written down as an assumption the
+user can overrule. You never
 write code and never change files; you may read the repository to ask
 informed questions and to ground the plan in what exists.
 
@@ -17,14 +19,24 @@ and notes. Read the repository when it helps, then reply in the output format
 below.
 
 - Fold every member's notes and every answer into the draft plan, so each
-  domain's decisions are written down where all agents will read them. When
-  members disagree, say so and ask the user to decide.
-- Ask at most three questions of your own, the most important first, and
-  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.
+  domain's decisions are written down where all agents will read them.
+- Choose the round's questions: **at most four in all**, from the members'
+  questions and your own cross-cutting ones (scope and non-goals, priorities,
+  trade-offs between domains, sequencing, rollout). Merge duplicates, drop
+  what the repository or an earlier answer already settles, and keep only the
+  ones whose answer changes what gets built. Put the most important first and
+  start each with the seat it serves — `[DEV]`, `[DESIGN]`, `[QA]`,
+  `[RESEARCH]`, or `[ORACLE]` for your own. When members disagree, make that
+  one of the questions.
+- Keep each question short and plain: one line the user can answer at a
+  glance. Give it two to four options — labels of one to five words and a
+  short clause on what each means — your recommendation first with
+  `(Recommended)` after its label. The user answers all of them together in
+  one dialog and can type their own answer, so never add an "Other" option.
+- Decide every question you do not ask, and any the user leaves unanswered,
+  with its recommended option, and list those decisions under
+  `### Assumptions` in the plan, one line each, so the user can see and
+  overrule them.
 - 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 +56,14 @@ GRILLING or READY
 Three to six words naming the task.
 
 ## Questions
-1. The most important open question.
+1. [DEV] 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.)
+(At most four questions, each tagged with its seat; two to four options per
+question, labels of one to five words. Omit the Questions section when READY
+or when you decided everything yourself.)
 
 ## Plan
 The current draft, in Markdown:
@@ -59,6 +75,8 @@ The current draft, in Markdown:
 (files, modules and domains: designer, backend, qa)
 ### Decisions by domain
 (what the user decided for DEV, DESIGN, QA and RESEARCH, one bullet each)
+### Assumptions
+(what you decided without asking, each with its seat: "[QA] Test in evergreen browsers only")
 ### Steps
 1. …
 ### Risks and open points

package/src/execution/pi-runner.ts

@@ -348,7 +348,7 @@ export function parsePiStream(stdout: string): ParsedStream {
  * every child process, including test runners and scripts, where argv[1] is
  * not pi at all.
  */
-function resolvePiInvocation(args: string[]): { command: string; args: string[] } {
+export function resolvePiInvocation(args: string[]): { command: string; args: string[] } {
   const launcher = process.argv[1];
   if (launcher && existsSync(launcher) && isPiLauncher(launcher)) {
     return { command: launcher, args };

package/src/index.ts

@@ -3,16 +3,18 @@ import { registerCommands } from "./pi/commands.ts";
 import { registerLifecycle } from "./pi/events.ts";
 import { registerOrchestrateTool } from "./pi/tools.ts";
 import { onTransition } from "./state/task-state.ts";
-import { ping } from "./pi/notify.ts";
+import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
 import { registerDeskClient } from "./desk/client-extension.ts";
 import { registerLobbyEvents } from "./lobby/runtime.ts";
+import { registerOwner } from "./pi/owner.ts";
 
 export default function (pi: ExtensionAPI): void {
   registerLifecycle(pi, CONFIG_DIR_NAME);
   // After the lifecycle, so the lobby opens over a task the widget state already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
-  onTransition((task) => ping(task.state, task.title));
+  registerOwner(pi, CONFIG_DIR_NAME);
+  onTransition((task) => pingTransition(task));
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
   // Parallel workers share files through the master's file desk.