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

package/README.md

@@ -273,6 +273,25 @@ Rebind any key under `lobby.keys` in the config.
 Pi session. The Lobby tab can show any session, and your prompt steers it;
 `● waiting` in the tab bar means one has a question for you.
 
+**Agents at work.** The bottom line of the lobby shows the subagents running
+right now at its right end (`◐ DESIGN editing 2m · DEV 40s`, a running quick
+fix too), shrinking to names and then a count when the keys leave little room.
+
+**Paging.** A pane with more lines than rows shows page buttons on its bottom
+edge, `▲▲ ▲ ▼ ▼▼`: click one to scroll a page up or down (`▲▲` and `▼▼` go two
+pages). The wheel, the arrows and PageUp/PageDown still work. It applies to
+every scrolling pane: the conversation, activity and thinking, the plan draft,
+the Tasks and Quick fix lists and details, and the metrics table.
+
+**Status line when hidden.** With the lobby hidden (`alt+l`), one line under
+Pi's editor shows where things stand: a bar of the task's plan steps (or its
+stage before there is a plan) with who is working, the planning round and the
+questions waiting for you, the quick fix in hand, or `idle`. It costs nothing
+while nothing changes. Turn it off with `lobby.miniLine: false` (or in
+`/bot-lobby settings` → Lobby).
+
+![The status line under the editor while the lobby is hidden: a task, planning, idle](https://raw.githubusercontent.com/a-t-h-i/bot-lobby/main/docs/lobby-status-line.png)
+
 The conversation keeps its newest 100 messages in memory; scroll to the top
 to load the rest.
 
@@ -307,7 +326,10 @@ can be compared by looking at them.
 
 `↑↓` move · `enter` choose · `space` pick several (multi-select) · `1`–`4`
 pick · `←→` between questions · the last row takes an answer in your own words
-· `esc` puts the questions away (what you answered is kept). Editor hosts that
+· `esc` asks whether to leave (a second `enter`
+leaves, anything else keeps you answering), so a stray press does nothing.
+Questions you leave are never answered for you: the oracle waits and asks again
+when you next write, and the designer asks again before it may decide. Editor hosts that
 run Pi in RPC mode get the same questions through Pi's own dialogs.
 
 **Images.** An option can also carry an `image`: a PNG, JPEG, GIF or WebP
@@ -413,9 +435,42 @@ the result.
   `off, minimal, low, medium, high, xhigh, max`, limited to what the model
   supports. Scouts always think at `low`.
 - `instructions` adds your own text to an agent's built-in prompt.
+- `fallbackModel` and `fallbackThinking` on any agent (and the master): see
+  [Fallback models](#fallback-models).
 - Classifier thresholds and limits (`classifier.thresholds`,
   `classifier.fileHints`) are edited in the file.
 
+## Fallback models
+
+Running the oracle on a subscription model and the agents on another provider
+means one of them can run out of usage mid-task. Give each agent class a
+**fallback model** and the **thinking level** to run it at (`/bot-lobby
+settings` → the agent → *Fallback model* / *Fallback thinking*). When a run
+fails because its model is out of usage, rate-limited, out of credit or
+unavailable, it runs again on the fallback instead of failing the task.
+
+- Works for the master, DESIGN, DEV, QA, the researcher, scouts (their fallback
+  thinks at `low` too), quick fixes and the planner and its panel seats.
+- The exhausted model is skipped for 20 minutes, so the next agents go straight
+  to their fallback instead of each spending a failed run finding out.
+- **The master** is your own Pi session: on a usage failure the session
+  switches to its fallback model and thinking level, tells you, and the oracle
+  carries on from where it stopped. Switch back with `/model` when your usage
+  returns.
+- Only usage, limit and availability errors switch model; an ordinary failure
+  still retries on the same model. If the fallback fails the same way, the run
+  fails: it does not chain to a third model.
+- The activity log says when an agent switched, and the run's receipts and the
+  Metrics tab show the model that actually ran.
+
+```json
+{
+  "master": { "model": "anthropic/claude-fable-5-1", "thinking": "high", "fallbackModel": "deepseek/deepseek-v3", "fallbackThinking": "medium" },
+  "agents": { "backend": { "model": "zai/glm-4.6", "thinking": "medium", "fallbackModel": "deepseek/deepseek-v3", "fallbackThinking": "low" } },
+  "scout": { "model": "zai/glm-4.6", "fallbackModel": "deepseek/deepseek-v3" }
+}
+```
+
 ## What the engine enforces
 
 | Rule | How |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/master.md

@@ -68,6 +68,12 @@ more), skip the researcher when research is not needed, clarify only when it
 reads the request as ambiguous — and overrule it whenever the repository says
 otherwise. It is a hint, never a rule.
 
+When the user leaves your questions unanswered (they put them away, or
+`ask_user_question` says so), the decision is still theirs: never assume the
+answers, never fall back on the recommended options, and never carry on with
+work that depends on them. Say in one short line that the questions are
+waiting, end your turn, and ask again when they next write.
+
 When you `clarify` with options, put your recommended option first and mark
 it `(Recommended)`. When the request already makes it clearly right, the
 classifier answers for you: the reply says so, the decision is recorded, and

package/src/ask/dialog.ts

@@ -9,7 +9,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
 import type { LobbyTheme } from "../lobby/layout.ts";
 import { lobbyTheme } from "../lobby/theme.ts";
-import { initialState, step, type AskKey, type AskState } from "./state.ts";
+import { initialState, putAway, step, type AskKey, type AskState } from "./state.ts";
 import { renderAsk, type AskFrame } from "./view.ts";
 import { loadImages } from "./image.ts";
 import { isAbsolute, resolve } from "node:path";
@@ -68,7 +68,9 @@ export class AskDialog implements Component {
 
   /** Put the questions away from outside (the turn was aborted). */
   cancel(): void {
-    if (!this.state.result) this.handleInput("\x1b");
+    if (this.state.result) return;
+    this.state = putAway(this.state);
+    this.done(this.state.result!);
   }
 
   render(width: number): string[] {

package/src/ask/state.ts

@@ -38,10 +38,17 @@ export interface AskState {
   /** Writing the own answer of the question in view. */
   editing: boolean;
   draft: string;
+  /** Esc was pressed: asked whether to leave without answering; enter leaves, any other key keeps answering. */
+  leaving?: boolean;
   /** Set once the user submits or puts the questions away. */
   result?: AskResult;
 }
 
+/** The questions put away, with what was answered so far (also when something outside ends them). */
+export function putAway(state: AskState): AskState {
+  return { ...state, editing: false, draft: "", leaving: false, result: { answers: answersOf(state), cancelled: true } };
+}
+
 export function initialState(questions: readonly AskQuestion[]): AskState {
   return {
     questions,
@@ -127,6 +134,8 @@ function typing(state: AskState, key: AskKey): AskState {
 /** One key press. */
 export function step(state: AskState, key: AskKey): AskState {
   if (state.result) return state;
+  // Esc asks first: leaving the questions unanswered lets the oracle carry on without you, so it takes a second key.
+  if (state.leaving) return key.type === "enter" || (key.type === "text" && key.value.toLowerCase() === "y") ? putAway(state) : { ...state, leaving: false };
   if (state.editing) return typing(state, key);
   const question = state.questions[state.tab];
   if (!question) return { ...state, result: { answers: [], cancelled: false } };
@@ -153,7 +162,7 @@ export function step(state: AskState, key: AskKey): AskState {
       return advance(state);
     }
     case "escape":
-      return { ...state, result: { answers: answersOf(state), cancelled: true } };
+      return { ...state, leaving: true };
     default:
       return state;
   }

package/src/ask/tool.ts

@@ -65,12 +65,16 @@ export function invalidQuestions(questions: readonly AskQuestion[]): string | un
   return undefined;
 }
 
+/** What the model does with questions the user left unanswered: wait, never fill them in. */
+const STILL_OPEN = "Do not assume answers, do not pick the recommended options, and do not go on with work that depends on them. Say in one short line that the questions are waiting, end your turn, and put them to the user again when they next write.";
+const NOT_ANSWERED = `The user left the questions without answering. ${STILL_OPEN}`;
+
 /** What the model reads back: each question with its answer, or that it was skipped. */
 export function answerSummary(questions: readonly AskQuestion[], result: AskResult): string {
   if (result.cancelled && result.answers.length === 0) {
     // A relay that could not ask anyone (auto mode) says why.
     if (result.globalNote) return result.globalNote;
-    return "The user put the questions away without answering. Do not ask the same again right away: go on with your best judgement and say what you assumed, or ask something narrower.";
+    return NOT_ANSWERED;
   }
   const lines = questions.map((question, index) => {
     const answer = result.answers.find((entry) => entry.questionIndex === index);
@@ -82,6 +86,7 @@ export function answerSummary(questions: readonly AskQuestion[], result: AskResu
   return [
     result.cancelled ? "The user answered some questions, then put the rest away:" : "The user answered:",
     ...lines,
+    ...(result.cancelled ? ["", `The questions marked "(not answered)" are still open. ${STILL_OPEN}`] : []),
     ...(result.globalNote ? ["", `Note: ${result.globalNote}`] : []),
   ].join("\n");
 }

package/src/ask/view.ts

@@ -112,6 +112,7 @@ function previewBox(preview: Preview, width: number, rows: number, theme: LobbyT
 }
 
 function hints(state: AskState, question: AskQuestion, width: number, theme?: LobbyTheme): string[] {
+  if (state.leaving) return wrap(paint(theme, "warning", "Leave without answering? The oracle will not guess for you. enter leaves · any other key keeps answering"), width);
   const parts = state.editing
     ? ["enter keep it", "esc back to the options"]
     : [
@@ -119,7 +120,7 @@ function hints(state: AskState, question: AskQuestion, width: number, theme?: Lo
         question.multiSelect ? "space pick · enter next" : "enter choose",
         `1-${question.options.length} pick`,
         ...(state.questions.length > 1 ? ["←→ questions"] : []),
-        "esc put away",
+        "esc leave",
       ];
   return wrap(paint(theme, "dim", parts.join(" · ")), width);
 }

package/src/execution/agent-runner.ts

@@ -7,6 +7,7 @@ import { shortDuration, truncate } from "../text.ts";
 import { EditLog } from "../state/changes.ts";
 import { formatMinutes, REPORT_GRACE_MS } from "../state/budget.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner, type RelayAsk } from "./pi-runner.ts";
+import { isUnavailable, looksUnavailable, markUnavailable, usableFallback } from "./fallback.ts";
 import { ASK_ENV } from "../ask/relay.ts";
 import { ASK_TOOL } from "../ask/types.ts";
 
@@ -40,6 +41,10 @@ export interface AgentRequest {
   context: AgentContext;
   model?: string;
   thinking?: string;
+  /** Where the run goes when its model runs out of usage or is unavailable. */
+  fallback?: { model: string; thinking: string };
+  /** Set by the runner once it has switched: the model that ran out. */
+  fellBackFrom?: string;
   timeoutMs: number;
   cwd: string;
   signal?: AbortSignal;
@@ -135,13 +140,24 @@ function retryable(run: AgentRun): boolean {
  */
 export async function runAgent(request: AgentRequest, run: ProcessRunner = spawnPiProcess): Promise<AgentRun> {
   const startedAt = new Date().toISOString();
-  const attempts = Math.max(1, (request.retries ?? 0) + 1);
+  let attempts = Math.max(1, (request.retries ?? 0) + 1);
   // A failed attempt may have edited files before the retry: the run owns every edit.
   const edits = new EditLog(request.cwd);
   let last: AgentRun | undefined;
+  // A model already known to be out of usage goes straight to the fallback.
+  const other = usableFallback(request.fallback, request.model);
+  if (other && isUnavailable(request.model)) request = switchToFallback(request, other, request.model ?? "the session model");
   for (let attempt = 1; attempt <= attempts; attempt++) {
     last = await runAgentOnce(request, run, attempt, startedAt, edits);
     request.onAttemptEnd?.(last);
+    // Out of usage (or the model unavailable): the same model would fail again, so the fallback takes the retry.
+    const fallback = usableFallback(request.fallback, request.model);
+    if (fallback && !request.fellBackFrom && last.status === "failed" && looksUnavailable(last.error)) {
+      if (request.model) markUnavailable(request.model);
+      request = switchToFallback(request, fallback, request.model ?? "the session model");
+      attempts += 1;
+      continue;
+    }
     if (!retryable(last)) break;
     // Under a budget a retry only uses what is left of the allotment.
     if (request.time && request.time.endsAt - Date.now() < MIN_ATTEMPT_MS) break;
@@ -150,6 +166,11 @@ export async function runAgent(request: AgentRequest, run: ProcessRunner = spawn
   return edited.length > 0 ? { ...last!, edited } : last!;
 }
 
+/** The request moved to its fallback model and thinking level. */
+function switchToFallback(request: AgentRequest, fallback: { model: string; thinking?: string }, from: string): AgentRequest {
+  return { ...request, model: fallback.model, thinking: fallback.thinking ?? request.thinking, fellBackFrom: from };
+}
+
 /** Abort every in-flight subagent (session shutdown, user cancel). */
 export function cancelAllRuns(): void {
   for (const controller of activeControllers) controller.abort();
@@ -168,6 +189,7 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     attempts,
     startedAt,
     ...(request.thinking ? { thinking: request.thinking } : {}),
+    ...(request.fellBackFrom ? { fellBackFrom: request.fellBackFrom } : {}),
     ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
     ...(request.route ? { route: request.route } : {}),
     ...(request.time ? { allotMs: request.time.allotMs, endsAt: request.time.endsAt } : {}),

package/src/execution/fallback.ts

@@ -0,0 +1,75 @@
+/**
+ * Fallback models. A subscription or key that runs out mid-task (a usage
+ * limit, a rate limit, no credit, the provider down or refusing the key)
+ * fails every run on that model the same way, so the run goes to the agent's
+ * configured fallback model instead, and the exhausted model is skipped for a
+ * while so the next agents do not each spend a failed run finding out.
+ */
+
+/** What a provider says when a model cannot be used right now. Deliberately narrow: an ordinary failure is not a reason to switch model. */
+const UNAVAILABLE = [
+  /usage limit/i, /rate.?limit/i, /\bquota\b/i, /limit (?:reached|exceeded|will reset)/i, /exceeded (?:your|the|current)/i,
+  /out of (?:usage|credits?|extra usage|tokens)/i, /(?:insufficient|no) (?:credits?|funds|balance|quota)/i, /credit balance/i,
+  /billing/i, /payment required/i, /\b402\b/, /\b429\b/, /too many requests/i, /resource.?exhausted/i,
+  /overloaded/i, /\b529\b/, /(?:at|over) capacity/i, /resets? (?:at|in|on)/i, /subscription/i,
+  /unauthori[sz]ed/i, /\b401\b/, /invalid (?:api )?key/i, /no api key/i, /authentication (?:failed|error)/i,
+  /model (?:is )?(?:not found|not available|unavailable)/i, /unknown model/i, /does not have access/i,
+];
+
+/** True when a failed run's error says its model is out of usage or unavailable, so another model may succeed. */
+export function looksUnavailable(error: string | undefined): boolean {
+  return Boolean(error && UNAVAILABLE.some((pattern) => pattern.test(error)));
+}
+
+/** How long a model that ran out is skipped before it is tried again. */
+export const COOLDOWN_MS = 20 * 60 * 1000;
+
+const exhausted = new Map<string, number>();
+
+/** Remember that `model` cannot be used until the cooldown passes. */
+export function markUnavailable(model: string, now = Date.now()): void {
+  exhausted.set(model, now + COOLDOWN_MS);
+}
+
+/** Whether `model` ran out recently enough to skip. */
+export function isUnavailable(model: string | undefined, now = Date.now()): boolean {
+  if (!model) return false;
+  const until = exhausted.get(model);
+  if (until === undefined) return false;
+  if (until <= now) {
+    exhausted.delete(model);
+    return false;
+  }
+  return true;
+}
+
+/** Forget every exhausted model (tests). */
+export function resetUnavailable(): void {
+  exhausted.clear();
+}
+
+/** A fallback worth switching to: a model other than the one that failed. */
+export function usableFallback<F extends { model: string }>(fallback: F | undefined, current: string | undefined): F | undefined {
+  return fallback && fallback.model !== current ? fallback : undefined;
+}
+
+/**
+ * Run `attempt` on `model`; when it fails because that model is out of usage
+ * or unavailable, run it again on the fallback. A model already known to be
+ * out goes straight to the fallback. `switched` says which model took over.
+ */
+export async function withFallback<T extends { status: string; error?: string }>(
+  model: string | undefined,
+  thinking: string,
+  fallback: { model: string; thinking: string } | undefined,
+  attempt: (model: string | undefined, thinking: string) => Promise<T>,
+): Promise<{ result: T; switchedFrom?: string }> {
+  const other = usableFallback(fallback, model);
+  if (other && isUnavailable(model)) return { result: await attempt(other.model, other.thinking), switchedFrom: model ?? "the session model" };
+  const result = await attempt(model, thinking);
+  if (other && result.status === "failed" && looksUnavailable(result.error)) {
+    if (model) markUnavailable(model);
+    return { result: await attempt(other.model, other.thinking), switchedFrom: model ?? "the session model" };
+  }
+  return { result };
+}

package/src/lobby/feed.ts

@@ -70,6 +70,8 @@ export class LobbyFeed {
   private readonly runSteps = new Map<string, string>();
   private readonly runThoughts = new Map<string, string>();
   private readonly runStatus = new Map<string, AgentRun["status"]>();
+  /** Runs already reported as switched to their fallback model. */
+  private readonly fellBack = new Set<string>();
 
   onChange(listener: () => void): () => void {
     this.listeners.add(listener);
@@ -200,6 +202,10 @@ export class LobbyFeed {
       const before = this.runStatus.get(key);
       this.runStatus.set(key, run.status);
       if (before === undefined) this.log(source, `started as ${run.role}`, "info", at);
+      if (run.fellBackFrom && !this.fellBack.has(key)) {
+        this.fellBack.add(key);
+        this.log(source, `${run.fellBackFrom} is out of usage or unavailable: running on the fallback model`, "warning", at);
+      }
       if (run.step && this.runSteps.get(key) !== run.step) {
         this.runSteps.set(key, run.step);
         this.step(source, run.step, key, at);
@@ -225,6 +231,7 @@ export class LobbyFeed {
     this.runSteps.clear();
     this.runThoughts.clear();
     this.runStatus.clear();
+    this.fellBack.clear();
     this.touch();
   }
 }

package/src/lobby/layout.ts

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

package/src/lobby/mini.ts

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

package/src/lobby/planner.ts

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