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

package/src/lobby/quickfix.ts

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

package/src/lobby/runtime.ts

@@ -35,7 +35,8 @@ import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, askUser, questionnaires, type Asker } from "./ask.ts";
-import { QuickFixQueue } from "./quickfix.ts";
+import { jobTitle, QuickFixQueue } from "./quickfix.ts";
+import { miniLine, type MiniInput } from "./mini.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
 import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type TabId } from "./view.ts";
@@ -94,18 +95,39 @@ let frameTimer: ReturnType<typeof setTimeout> | undefined;
  * through pi.
  */
 function rerender(): void {
-  if (!runtime?.visible || frameTimer) return;
+  // Hidden, only the one-line status under the editor changes.
+  if (!runtime || (!runtime.visible && !miniShown(runtime)) || frameTimer) return;
   const wait = lastFrame + FRAME_MS - Date.now();
   const paint = () => {
     frameTimer = undefined;
     lastFrame = Date.now();
-    if (runtime?.visible) runtime.tui?.requestRender();
+    if (runtime?.visible || (runtime && miniShown(runtime))) runtime.tui?.requestRender();
   };
   if (wait <= 0) return paint();
   frameTimer = setTimeout(paint, wait);
   frameTimer.unref?.();
 }
 
+/** The status line shows under the editor while the lobby is hidden (not while bot-lobby is minimized), unless settings turn it off. */
+function miniShown(state: Runtime): boolean {
+  return !state.visible && !isMinimized() && loadConfig().lobby.miniLine;
+}
+
+/** What the status line shows: the task, the planning round, the quick fix in hand. */
+function miniInput(state: Runtime): MiniInput {
+  const snapshot = taskSnapshot();
+  const planner = state.planner;
+  const job = state.quickfix.running ?? state.quickfix.jobs.find((entry) => entry.status === "queued");
+  const queued = state.quickfix.jobs.filter((entry) => entry.status === "queued" && entry !== job).length;
+  return {
+    ...(snapshot.task ? { task: snapshot.task } : {}),
+    runs: snapshot.runs,
+    ...(planner ? { planning: { busy: planner.busy, round: planner.turns, limit: loadConfig().lobby.maxPlanningRounds, questions: planner.awaitingAnswers ? planner.questions.length : 0, ready: planner.reply?.status === "ready", saved: Boolean(planner.saved) } } : {}),
+    ...(job ? { quickfix: { title: jobTitle(job), running: job.status === "running", queued } } : {}),
+    key: "Alt+L",
+  };
+}
+
 function sessionModel(ctx: ExtensionContext): string | undefined {
   return ctx.model ? modelRef(ctx.model) : undefined;
 }
@@ -769,7 +791,8 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
   // Capture pi's TUI through a zero-line widget below the editor.
   ctx.ui.setWidget(ANCHOR_KEY, (tui) => {
     state.tui = tui;
-    return { render: () => [], invalidate: () => {} };
+    // Zero lines while the lobby is up (or bot-lobby is minimized); one status line when it is hidden.
+    return { render: (width: number) => (miniShown(state) ? [miniLine(miniInput(state), width, lobbyTheme(state.ctx.ui.theme))] : []), invalidate: () => {} };
   }, { placement: "belowEditor" });
   // The owner's clock (pi/owner.ts) delivers comments and messages and drives auto mode; the lobby logs what it did.
   onOwnerEvent((event) => {

package/src/lobby/view.ts

@@ -22,8 +22,9 @@ import type { BackgroundSession } from "./sessions.ts";
 import type { QuickFixQueue } from "./quickfix.ts";
 import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } from "./planner.ts";
 import { issueText, type IssuesState } from "./issues.ts";
+import { agentsIndicator, workingAgents } from "./mini.ts";
 import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, type KeyMap, type LobbyAction } from "./keys.ts";
-import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
+import { beside, bold, box, fit, highlight, pagerButton, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
 import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
 import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
 import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
@@ -816,7 +817,7 @@ export class LobbyView implements Component, Focusable {
    * end. Lists move their selection instead; the draft moves its cursor (the
    * wheel scrolls it and the cursor follows only when it would leave the screen).
    */
-  private scrollPane(pane: string, delta: number, wheel = false): void {
+  private scrollPane(pane: string, delta: number, wheel = false, page = false): void {
     if (delta === 0) return;
     switch (pane) {
       case "conversation":
@@ -828,13 +829,13 @@ export class LobbyView implements Component, Focusable {
         this.planOffset = Math.max(0, this.planOffset - delta);
         break;
       case "draft":
-        if (wheel) this.wheelDraft(delta);
+        if (wheel || page) this.wheelDraft(delta);
         else this.moveCursor(delta);
         break;
       case "list":
-        if (this.tab === "tasks") this.selectTask(this.tasksSelected + Math.sign(delta));
+        if (this.tab === "tasks") this.selectTask(this.tasksSelected + (page ? delta : Math.sign(delta)));
         else if (this.tab === "quickfix") {
-          this.fixSelected = Math.max(0, Math.min(this.fixJobs().length - 1, this.fixSelected + Math.sign(delta)));
+          this.fixSelected = Math.max(0, Math.min(this.fixJobs().length - 1, this.fixSelected + (page ? delta : Math.sign(delta))));
           this.fixDetailOffset = 0;
         }
         break;
@@ -843,7 +844,7 @@ export class LobbyView implements Component, Focusable {
         else if (this.tab === "quickfix") this.fixDetailOffset = Math.max(0, this.fixDetailOffset + delta);
         break;
       case "table":
-        this.metricsSelected = Math.max(0, this.metricsSelected + (wheel ? Math.sign(delta) : delta));
+        this.metricsSelected = Math.max(0, this.metricsSelected + (wheel && !page ? Math.sign(delta) : delta));
         break;
     }
     this.clampScroll();
@@ -1640,6 +1641,15 @@ export class LobbyView implements Component, Focusable {
     if (this.tab === "lobby" && pane) this.homeFocus = pane as HomePane;
     if (this.tab === "tasks" && (pane === "list" || pane === "detail")) this.tasksFocus = pane;
     if (this.tab === "quickfix" && (pane === "list" || pane === "detail")) this.fixFocus = pane;
+    // The page buttons in a scrolling pane's bottom border scroll it a page or two.
+    const paneBox = pane ? this.panes.get(pane) : undefined;
+    if (pane && paneBox && paneBox.total > paneBox.rows && row === paneBox.top + paneBox.height - 1) {
+      const button = pagerButton(paneBox.width, x - paneBox.left);
+      if (button) {
+        this.scrollPane(pane, button * Math.max(1, paneBox.rows - 1), false, true);
+        return;
+      }
+    }
     if (this.tab !== "plan" || row < 0 || !this.host.planner()) return;
     const layout = this.planLayout;
     // The draft pane: its border sits one row above its first line and two columns left of its text.
@@ -1978,7 +1988,11 @@ export class LobbyView implements Component, Focusable {
     if (this.help) return fit(`${badge("KEYS", "accent")} ${this.chips([["any key", "closes"]], theme)}`, width);
     if (this.searching) return fit(`${badge("SEARCH", "warning")} ${this.chips([["enter", "keep"], ["esc", "clear"], ["↑↓", "results"], [k("nextTab"), "next tab"]], theme)}`, width);
     const mode = this.mode === "type" ? badge("TYPE", "accent") : badge("BROWSE", "muted");
-    return fit(`${mode} ${this.chips(this.hintChips(), theme)}`, width);
+    const keys = `${mode} ${this.chips(this.hintChips(), theme)}`;
+    // The subagents at work sit at the right end of the line, when the keys leave room.
+    const working = this.viewing.kind === "here" ? agentsIndicator(workingAgents(this.host.zen().runs, this.host.quickfix.running), this.now(), spinner(this.tick), width - textWidth(keys) - 3, theme) : "";
+    const gap = width - textWidth(keys) - textWidth(working) - 1;
+    return working && gap >= 2 ? `${keys}${" ".repeat(gap)}${working} ` : fit(keys, width);
   }
 
   /**
@@ -2054,6 +2068,7 @@ export class LobbyView implements Component, Focusable {
       ...row("Ctrl+C", "clear the prompt, or hide the lobby", inner),
       ...row("click", "a tab to open it, a pane to give it the keys, a draft plan line to comment on it", inner),
       ...row("wheel", "scroll the pane under the pointer", inner),
+      ...row("▲ ▼", "click the buttons on a pane's bottom edge: a page up or down (▲▲ ▼▼ two pages)", inner),
     ];
     const modes = (inner: number) => [
       section("Typing"),

package/src/master/master.ts

@@ -49,7 +49,7 @@ export interface ScoutRequest {
 /** Model, thinking and time limit for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs };
+  return { model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs, ...(profile.fallback ? { fallback: profile.fallback } : {}) };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {

package/src/master/research.ts

@@ -88,6 +88,7 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       model: profile.model,
       thinking: profile.thinking,
       timeoutMs: profile.timeoutMs,
+      ...(profile.fallback ? { fallback: profile.fallback } : {}),
       ...(request.time ? { time: request.time } : {}),
       cwd: request.cwd,
       signal: request.signal,

package/src/pi/events.ts

@@ -7,6 +7,7 @@ import { selectKnowledge } from "../knowledge/selector.ts";
 import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
+import { registerMasterFallback } from "./master-fallback.ts";
 import { applyStatus, clearStatus, isMinimized, setMinimized } from "./ui.ts";
 import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
@@ -64,6 +65,7 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
  * section rather than replacing the whole prompt.
  */
 export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
+  registerMasterFallback(pi);
   // Web tools the oracle put away for the task in hand, given back when it ends.
   let hiddenWeb: string[] = [];
   pi.on("session_start", (_event, ctx) => {

package/src/pi/master-fallback.ts

@@ -0,0 +1,61 @@
+/**
+ * The master runs in your own Pi session, on the session's model. When that
+ * model runs out of usage mid-task (a subscription limit, no credit) the turn
+ * ends with an error and the task would stall. With a fallback model set for
+ * the master, the session switches to it and the oracle carries on.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { looksUnavailable, markUnavailable } from "../execution/fallback.ts";
+import { fallbackOf } from "../schemas/configuration.ts";
+import { loadConfig } from "../state/project.ts";
+import { modelRef } from "./model-support.ts";
+import { modelLookup } from "./tools.ts";
+import { isSubagentProcess } from "./quiet.ts";
+
+/** The provider's error when the last thing in the turn was a failed assistant message that says the model is out of usage or unavailable. */
+export function usageFailure(messages: readonly unknown[]): string | undefined {
+  const last = messages.at(-1) as { role?: string; stopReason?: string; errorMessage?: string } | undefined;
+  if (last?.role !== "assistant" || last.stopReason !== "error") return undefined;
+  return looksUnavailable(last.errorMessage) ? last.errorMessage : undefined;
+}
+
+/** What the oracle is told after the switch. */
+export function switchedMessage(from: string, to: string): string {
+  return `bot-lobby: your last turn failed because ${from} is out of usage or unavailable, so this session switched to ${to}. Carry on with the task from where you left off; do not repeat work that is already done.`;
+}
+
+export function registerMasterFallback(pi: ExtensionAPI): void {
+  if (isSubagentProcess()) return;
+  let failure: string | undefined;
+  pi.on("agent_end", (event) => {
+    failure = usageFailure(event.messages);
+  });
+  pi.on("agent_settled", async (_event, ctx: ExtensionContext) => {
+    if (!failure) return;
+    failure = undefined;
+    await switchMaster(pi, ctx);
+  });
+}
+
+async function switchMaster(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  const fallback = fallbackOf(loadConfig().master);
+  if (!fallback) return;
+  const current = ctx.model ? modelRef(ctx.model) : "the session model";
+  if (current === fallback.model) {
+    ctx.ui.notify(`bot-lobby: ${current} (the master's fallback) is out of usage too — pick another model or wait.`, "warning");
+    return;
+  }
+  const model = modelLookup(ctx)(fallback.model);
+  if (!model) {
+    ctx.ui.notify(`bot-lobby: the master's fallback model "${fallback.model}" is not known to Pi.`, "warning");
+    return;
+  }
+  if (!(await pi.setModel(model))) {
+    ctx.ui.notify(`bot-lobby: no auth for the master's fallback model ${fallback.model}.`, "warning");
+    return;
+  }
+  pi.setThinkingLevel(fallback.thinking as Parameters<ExtensionAPI["setThinkingLevel"]>[0]);
+  if (ctx.model) markUnavailable(current);
+  ctx.ui.notify(`bot-lobby: ${current} ran out of usage; the master now runs on ${fallback.model} (${fallback.thinking}). Switch back with /model when it is available again.`, "warning");
+  await pi.sendUserMessage(switchedMessage(current, fallback.model));
+}

package/src/pi/model-support.ts

@@ -8,6 +8,7 @@ import {
   type PanelMember,
   THINKING_LEVELS,
   type BotLobbyConfig,
+  type FallbackProfile,
   type ProfileResolver,
   type SubagentKind,
   type ThinkingLevelName,
@@ -86,11 +87,25 @@ export function createProfileResolver(config: BotLobbyConfig, options: ResolverO
         options.warn?.(message);
       }
     }
-    return { ...profile, model, thinking: check.level };
+    return { ...profile, model, thinking: check.level, ...clampedFallback(profile.fallback, kindLabel(profile.kind as SubagentKind), options) };
   };
 }
 
-type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string };
+/** The fallback with its thinking level clamped to what the fallback model supports. */
+function clampedFallback(fallback: FallbackProfile | undefined, label: string, options: ResolverOptions): { fallback?: FallbackProfile } {
+  if (!fallback) return {};
+  const check = checkThinking(options.lookup(fallback.model), fallback.thinking);
+  if (check.warning) {
+    const message = `bot-lobby: ${label} fallback — ${check.warning}. Change it in /bot-lobby settings.`;
+    if (!warned.has(message)) {
+      warned.add(message);
+      options.warn?.(message);
+    }
+  }
+  return { fallback: { model: fallback.model, thinking: check.level } };
+}
+
+type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile };
 
 /** Unset models run on the session's; thinking is clamped to the model, with a one-time warning. */
 function resolveRunProfile(profile: RunProfile, label: string, options: ResolverOptions): RunProfile {
@@ -103,7 +118,7 @@ function resolveRunProfile(profile: RunProfile, label: string, options: Resolver
       options.warn?.(message);
     }
   }
-  return { ...profile, model, thinking: check.level };
+  return { ...profile, model, thinking: check.level, ...clampedFallback(profile.fallback, label, options) };
 }
 
 /** A lobby agent's model, thinking and time limit. */

package/src/pi/settings-ui.ts

@@ -40,11 +40,14 @@ interface EntryView {
   thinking?: string;
   instructions?: string;
   timeoutMs?: number;
+  /** The model this agent switches to when its own runs out of usage; unset = none. */
+  fallbackModel?: string;
+  fallbackThinking?: string;
 }
 
 function entryView(config: BotLobbyConfig, kind: SettingsKind): EntryView {
   if (kind === "master") return config.master;
-  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs };
+  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs, ...(config.scout.fallbackModel ? { fallbackModel: config.scout.fallbackModel } : {}) };
   if (kind === "researcher") return config.researcher;
   if (kind === "quickfix") return config.quickFix;
   if (kind === "planner") return config.planner;
@@ -56,21 +59,33 @@ interface EntryPatch {
   thinking?: string;
   instructions?: string;
   timeoutMs?: number;
+  /** `inherit` clears the fallback (its thinking level with it). */
+  fallbackModel?: string;
+  fallbackThinking?: string;
+}
+
+/** A settings entry with the fallback patch applied: `inherit` removes the fallback model and its thinking. */
+function withFallbackPatch<T extends { fallbackModel?: string; fallbackThinking?: string }>(entry: T): T {
+  if (entry.fallbackModel !== INHERIT_MODEL) return entry;
+  const { fallbackModel: _model, fallbackThinking: _thinking, ...rest } = entry;
+  return rest as T;
 }
 
 /** Apply a patch to one entry in a config copy; scouts ignore thinking and instructions. */
 export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: EntryPatch): BotLobbyConfig {
   const next: BotLobbyConfig = { ...config, agents: { ...config.agents } };
-  if (kind === "master") next.master = { ...config.master, ...patch } as AgentModelConfig;
+  if (kind === "master") next.master = withFallbackPatch({ ...config.master, ...patch } as AgentModelConfig);
   else if (kind === "scout") {
-    next.scout = {
+    const fallbackModel = patch.fallbackModel ?? config.scout.fallbackModel;
+    next.scout = withFallbackPatch({
       model: patch.model ?? config.scout.model,
       timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs,
-    };
-  } else if (kind === "researcher") next.researcher = { ...config.researcher, ...patch } as AgentModelConfig;
-  else if (kind === "quickfix") next.quickFix = { ...config.quickFix, ...patch } as AgentModelConfig;
-  else if (kind === "planner") next.planner = { ...config.planner, ...patch } as AgentModelConfig;
-  else next.agents[kind] = { ...config.agents[kind], ...patch } as AgentModelConfig;
+      ...(fallbackModel ? { fallbackModel } : {}),
+    });
+  } else if (kind === "researcher") next.researcher = withFallbackPatch({ ...config.researcher, ...patch } as AgentModelConfig);
+  else if (kind === "quickfix") next.quickFix = withFallbackPatch({ ...config.quickFix, ...patch } as AgentModelConfig);
+  else if (kind === "planner") next.planner = withFallbackPatch({ ...config.planner, ...patch } as AgentModelConfig);
+  else next.agents[kind] = withFallbackPatch({ ...config.agents[kind], ...patch } as AgentModelConfig);
   return next;
 }
 
@@ -275,6 +290,37 @@ async function editThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: Setti
   await commit(pi, ctx, kind, { thinking: level }, `thinking → ${level}`);
 }
 
+/** The model an entry falls back to when its own runs out of usage; `none` removes it. */
+async function editFallbackModel(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  const current = view.fallbackModel ?? INHERIT_MODEL;
+  const none: SelectItem = { value: INHERIT_MODEL, label: current === INHERIT_MODEL ? "none ✓" : "none", description: "No fallback: when its model runs out of usage the run fails" };
+  const choice = await pick(ctx, `Fallback model — ${kindLabel(kind)}`, [none, ...modelItems(ctx, current, false)], { search: true });
+  if (choice === undefined) return;
+  const typed = choice === CUSTOM_MODEL ? (await ctx.ui.input("Model id", "provider/model"))?.trim() : choice;
+  if (!typed) return;
+  await commit(pi, ctx, kind, { fallbackModel: typed }, typed === INHERIT_MODEL ? "fallback removed" : `fallback model → ${typed}`);
+  if (typed === INHERIT_MODEL || kind === "scout") return;
+  // Keep the fallback's thinking level one its model can run.
+  const level = entryView(loadConfig(), kind).fallbackThinking;
+  const check = level ? checkThinking(modelLookup(ctx)(typed), level) : undefined;
+  if (check?.warning) {
+    updateEntry(kind, { fallbackThinking: check.level });
+    ctx.ui.notify(`bot-lobby: ${kindLabel(kind)} fallback — ${check.warning}.`, "warning");
+  }
+}
+
+/** The thinking level on the fallback model, limited to what that model supports. */
+async function editFallbackThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  if (!view.fallbackModel) return;
+  const model = modelLookup(ctx)(view.fallbackModel);
+  const title = `Fallback thinking — ${kindLabel(kind)} (${view.fallbackModel})`;
+  const level = await pick(ctx, title, thinkingItems(supportedThinking(model), view.fallbackThinking ?? view.thinking));
+  if (!level || !isThinkingLevel(level)) return;
+  await commit(pi, ctx, kind, { fallbackThinking: level }, `fallback thinking → ${level}`);
+}
+
 async function editTimeout(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
   const current = entryView(loadConfig(), kind).timeoutMs ?? loadConfig().workflow.agentTimeoutMs;
   const typed = (await ctx.ui.input(`Time limit (minutes) — ${kindLabel(kind)}`, String(Math.round(current / 60_000))))?.trim();
@@ -303,6 +349,8 @@ export function entryItems(kind: SettingsKind, view: EntryView): SelectItem[] {
   const items: SelectItem[] = [{ value: "model", label: "Model", description: view.model }];
   if (kind === "scout") items.push({ value: "fixed", label: "Thinking", description: `${SCOUT_THINKING} (fixed for scouts)` });
   else items.push({ value: "thinking", label: "Thinking", description: view.thinking ?? "" });
+  items.push({ value: "fallback", label: "Fallback model", description: view.fallbackModel ?? "none · used when this model runs out of usage" });
+  if (kind !== "scout" && view.fallbackModel) items.push({ value: "fallbackThinking", label: "Fallback thinking", description: view.fallbackThinking ?? view.thinking ?? "" });
   if (kind !== "master") items.push({ value: "timeout", label: "Time limit", description: minutes(view.timeoutMs) });
   if (kind !== "scout" && kind !== "researcher") {
     items.push({ value: "instructions", label: "Instructions", description: view.instructions ? `${view.instructions.length} chars` : "(none)" });
@@ -317,6 +365,8 @@ async function editEntry(pi: ExtensionAPI, ctx: ExtensionContext, kind: Settings
     if (!action || action === "back") return;
     if (action === "model") await editModel(pi, ctx, kind);
     else if (action === "thinking") await editThinking(pi, ctx, kind);
+    else if (action === "fallback") await editFallbackModel(pi, ctx, kind);
+    else if (action === "fallbackThinking") await editFallbackThinking(pi, ctx, kind);
     else if (action === "timeout") await editTimeout(pi, ctx, kind);
     else if (action === "instructions") await editInstructions(pi, ctx, kind);
   }
@@ -352,11 +402,12 @@ function entryDescription(kind: SettingsKind, view: EntryView): string {
   const thinking = kind === "scout" ? SCOUT_THINKING : view.thinking;
   const custom = view.instructions ? " · custom" : "";
   const limit = kind === "master" ? "" : ` · ${minutes(view.timeoutMs)}`;
-  return `${view.model} · ${thinking}${limit}${custom}`;
+  const fallback = view.fallbackModel ? ` · fallback ${view.fallbackModel}` : "";
+  return `${view.model} · ${thinking}${limit}${custom}${fallback}`;
 }
 
 /** The lobby's on/off settings as the settings menu lists them; `panel:*` are the Lobby tab's panes. */
-export type LobbySwitch = "autoOpen" | "autoAsk" | "mouse" | "issues" | `panel:${LobbyPanel}`;
+export type LobbySwitch = "autoOpen" | "autoAsk" | "mouse" | "miniLine" | "issues" | `panel:${LobbyPanel}`;
 
 const PANEL_SWITCH_LABELS: Record<LobbyPanel, string> = { conversation: "Conversation pane", activity: "Activity log pane", thinking: "Thinking pane" };
 
@@ -364,6 +415,7 @@ export const LOBBY_SWITCHES: ReadonlyArray<{ id: LobbySwitch; label: string; hel
   { id: "autoOpen", label: "Open with a task", help: "open the lobby when this session starts or resumes a task" },
   { id: "autoAsk", label: "Ask at once", help: "put the panel's questions to you as soon as a round ends, while the Plan tab is open" },
   { id: "mouse", label: "Mouse", help: "click tabs and draft lines, scroll with the wheel (shift+drag still selects text)" },
+  { id: "miniLine", label: "Status line when hidden", help: "one line under the editor while the lobby is hidden: task steps, the planning round, a quick fix, or idle" },
   { id: "issues", label: "Issues tab", help: "the GitHub Issues tab" },
   ...LOBBY_PANELS.map((panel) => ({
     id: `panel:${panel}` as const,
@@ -419,6 +471,7 @@ function lobbySummary(config: BotLobbyConfig): string {
     config.lobby.autoOpen ? "opens with a task" : "opens on alt+l",
     config.lobby.autoAsk ? "asks at once" : "asks on enter",
     config.lobby.mouse ? "mouse" : "no mouse",
+    ...(config.lobby.miniLine ? [] : ["no status line"]),
     `planning: ${roundLimitLabel(config.lobby.maxPlanningRounds)}`,
     ...(config.lobby.issues ? ["issues tab"] : []),
     ...(hidden.length > 0 ? [`hidden: ${hidden.join(", ")}`] : []),

package/src/schemas/configuration.ts

@@ -31,12 +31,18 @@ export interface AgentModelConfig {
   instructions?: string;
   /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
   timeoutMs?: number;
+  /** Model this agent switches to when its own model runs out of usage or is unavailable; unset or `inherit` = none. */
+  fallbackModel?: ModelRef;
+  /** Thinking level on the fallback model; unset uses this agent's own `thinking`. */
+  fallbackThinking?: string;
 }
 
 /** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
 export interface ScoutConfig {
   model: ModelRef;
   timeoutMs: number;
+  /** Model scouts switch to when theirs runs out of usage or is unavailable (they think at `SCOUT_THINKING` on it too). */
+  fallbackModel?: ModelRef;
 }
 
 /** Subagent kinds with their own settings entry. */
@@ -114,6 +120,8 @@ export interface LobbyConfig {
   panels: Record<LobbyPanel, boolean>;
   /** Key overrides by action name, e.g. `{ "toggleThinking": "alt+t" }`. */
   keys: Record<string, string>;
+  /** A one-line status (task steps, planning round, quick fix, or idle) under the editor while the lobby is hidden. */
+  miniLine: boolean;
   /** Clicks and the wheel work in the lobby (click a draft line to comment on it); shift+drag still selects text. */
   mouse: boolean;
   /**
@@ -231,6 +239,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     panels: { conversation: true, activity: true, thinking: true },
     keys: {},
     mouse: true,
+    miniLine: true,
     maxPlanningRounds: 5,
   },
   classifier: {
@@ -266,18 +275,22 @@ function positive(value: unknown): number | undefined {
 
 /** Merge one agent's override over its default; legacy `inherit` or unknown thinking falls back to the default level. */
 function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConfig> | undefined): AgentModelConfig {
-  const merged = { ...base, ...(override ?? {}) };
+  const { fallbackModel: rawModel, fallbackThinking: rawThinking, ...merged } = { ...base, ...(override ?? {}) };
   const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
   const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
-  return { ...merged, thinking, ...(timeoutMs ? { timeoutMs } : {}) };
+  const fallbackModel = typeof rawModel === "string" && rawModel.trim() && rawModel !== INHERIT_MODEL ? rawModel.trim() : undefined;
+  const fallbackThinking = typeof rawThinking === "string" && isThinkingLevel(rawThinking) ? rawThinking : undefined;
+  return { ...merged, thinking, ...(timeoutMs ? { timeoutMs } : {}), ...(fallbackModel ? { fallbackModel, ...(fallbackThinking ? { fallbackThinking } : {}) } : {}) };
 }
 
 /** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
 function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig {
   const base = DEFAULT_CONFIG.scout;
+  const fallback = override?.fallbackModel;
   return {
     model: typeof override?.model === "string" && override.model.trim() ? override.model : base.model,
     timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
+    ...(typeof fallback === "string" && fallback.trim() && fallback !== INHERIT_MODEL ? { fallbackModel: fallback.trim() } : {}),
   };
 }
 
@@ -286,7 +299,7 @@ function flag(value: unknown, fallback: boolean): boolean {
 }
 
 function normalizeLobby(value: unknown): LobbyConfig {
-  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; maxPlanningRounds?: unknown } | undefined;
+  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; miniLine?: unknown; maxPlanningRounds?: unknown } | undefined;
   const defaults = DEFAULT_CONFIG.lobby;
   const panel = Array.isArray(source?.planningPanel)
     ? [...new Set(source.planningPanel.filter((entry): entry is PanelMember => typeof entry === "string" && isPanelMember(entry)))]
@@ -301,6 +314,7 @@ function normalizeLobby(value: unknown): LobbyConfig {
     panels: Object.fromEntries(LOBBY_PANELS.map((name) => [name, flag(panels[name], defaults.panels[name])])) as Record<LobbyPanel, boolean>,
     keys: Object.fromEntries(Object.entries(keys).filter((entry): entry is [string, string] => typeof entry[1] === "string" && entry[1].trim().length > 0)),
     mouse: flag(source?.mouse, defaults.mouse),
+    miniLine: flag(source?.miniLine, defaults.miniLine),
     maxPlanningRounds: roundLimit(source?.maxPlanningRounds, defaults.maxPlanningRounds),
   };
 }
@@ -390,6 +404,22 @@ export interface AgentProfile {
   thinking: string;
   timeoutMs: number;
   instructions?: string;
+  /** Where the run goes when its model runs out of usage or is unavailable; absent = it just fails. */
+  fallback?: FallbackProfile;
+}
+
+/** The fallback model and the thinking level to run it at. */
+export interface FallbackProfile {
+  model: string;
+  thinking: string;
+}
+
+/** The fallback of a settings entry: its model and thinking (the entry's own level when none is set). */
+export function fallbackOf(entry: { fallbackModel?: string; fallbackThinking?: string; thinking?: string }): FallbackProfile | undefined {
+  const model = modelOf(entry.fallbackModel ?? INHERIT_MODEL);
+  if (!model) return undefined;
+  const own = entry.thinking && isThinkingLevel(entry.thinking) ? entry.thinking : DEFAULT_THINKING;
+  return { model, thinking: entry.fallbackThinking && isThinkingLevel(entry.fallbackThinking) ? entry.fallbackThinking : own };
 }
 
 /** The settings entry a domain/role run draws from. */
@@ -414,10 +444,12 @@ export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role)
   const instructions = config.agents[domain].instructions;
   const fallback = config.workflow.agentTimeoutMs;
   if (kind === "scout") {
-    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions };
+    const scoutFallback = fallbackOf({ fallbackModel: config.scout.fallbackModel, thinking: SCOUT_THINKING });
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(scoutFallback ? { fallback: scoutFallback } : {}) };
   }
   const entry = kind === "researcher" ? config.researcher : config.agents[kind];
-  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions };
+  const entryFallback = fallbackOf(entry);
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entryFallback ? { fallback: entryFallback } : {}) };
 }
 
 /** The settings entry of a lobby agent (quick fix or planner). */
@@ -426,19 +458,21 @@ export function lobbyAgentConfig(config: BotLobbyConfig, kind: LobbyAgentKind):
 }
 
 /** Profile for a lobby agent run, from settings alone; `model` is undefined while unset. */
-export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string } {
+export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile } {
   const entry = lobbyAgentConfig(config, kind);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions };
+  const fallback = fallbackOf(entry);
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(fallback ? { fallback } : {}) };
 }
 
 /**
  * A planning panel seat's profile: the domain's (or the researcher's) model,
  * thinking and custom instructions, bounded by the planner's per-turn limit.
  */
-export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string } {
+export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile } {
   const entry = member === "researcher" ? config.researcher : config.agents[member];
   const timeoutMs = config.planner.timeoutMs ?? config.workflow.agentTimeoutMs;
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions };
+  const fallback = fallbackOf(entry);
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(fallback ? { fallback } : {}) };
 }
 
 /** Resolves the model, thinking and time limit one subagent run uses. */

package/src/schemas/findings.ts

@@ -139,6 +139,8 @@ export interface AgentRun {
   wrappedUp?: boolean;
   /** File this worker is queued for at the file desk. */
   waitingFor?: string;
+  /** The run switched to its fallback model because this one ran out of usage or was unavailable. */
+  fellBackFrom?: string;
   /** The classifier routed this run down: the configured profile it came from (`p/big · medium`). */
   routedFrom?: string;
   /** Why and where it was routed (`trivial 0.88: p/big · medium → p/cheap · low`). */