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

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";
@@ -54,8 +55,8 @@ const PROMPT_FIRST: ReadonlySet<TabId> = new Set(["lobby", "plan", "quickfix"]);
 export type LobbyMode = "type" | "browse";
 
 /** What each pane toggle is called in notices and help. */
-const PANEL_NAMES: Record<LobbyPanel, string> = { animations: "oracle and agent animations", conversation: "conversation", activity: "activity log", thinking: "thinking" };
-const PANEL_ACTIONS: Record<LobbyPanel, LobbyAction> = { animations: "toggleScene", conversation: "toggleConversation", activity: "toggleActivity", thinking: "toggleThinking" };
+const PANEL_NAMES: Record<LobbyPanel, string> = { conversation: "conversation", activity: "activity log", thinking: "thinking" };
+const PANEL_ACTIONS: Record<LobbyPanel, LobbyAction> = { conversation: "toggleConversation", activity: "toggleActivity", thinking: "toggleThinking" };
 
 /**
  * Which session the Lobby tab shows and talks to: this window, one it started
@@ -125,12 +126,8 @@ export interface LobbyHost {
   rows(): number;
   theme(): LobbyTheme;
   sessionId(): string | undefined;
-  /** This session's active task and its runs, as the zen widget sees them. */
+  /** This session's active task and its runs, as the lobby reads them. */
   zen(): { task?: Task; runs: readonly AgentRun[] };
-  /** Draw the zen scene into at most `height` lines: animated, or only the task's status when `animated` is false. */
-  scene(width: number, height: number, animated: boolean): string[];
-  /** Advance the scene's clock; returns the delay it wants until the next step. */
-  advanceScene(now: number): number;
   feed: LobbyFeed;
   masterBusy(): boolean;
   tasks(): Task[];
@@ -199,14 +196,12 @@ export interface LobbyHost {
   hasOlderChat(sessionId: string): boolean;
   /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
   chatHistory(sessionId?: string): readonly ChatEntry[];
-  /** A task's status without animations, for a session other than this window's. */
-  taskScene(task: Task, width: number, height: number): string[];
   profileLabel(kind: LobbyAgentKind): string;
   requestRender(): void;
   now?(): number;
 }
 
-/** Live work speeds the clock up so spinners and the scene move. */
+/** Live work speeds the clock up so spinners move. */
 export const LIVE_MS = 250;
 export const IDLE_MS = 1000;
 /** How often task and metrics data is reread from disk while the lobby is open. */
@@ -424,16 +419,13 @@ export class LobbyView implements Component, Focusable {
       || Boolean(zen.task && !zen.task.paused && !TERMINAL_STATES.includes(zen.task.state));
   }
 
-  /** One clock step: advance the scene, reread data when due, repaint. */
+  /** One clock step: reread data when due, repaint. */
   private step(): void {
     if (!this.running) return;
-    const now = this.now();
     this.tick += 1;
-    let delay = this.isLive() ? LIVE_MS : IDLE_MS;
-    if (this.tab === "lobby" && this.panels.animations && this.host.zen().task) delay = Math.min(delay, this.host.advanceScene(now));
     this.refreshData(false);
     this.host.requestRender();
-    this.schedule(delay);
+    this.schedule(this.isLive() ? LIVE_MS : IDLE_MS);
   }
 
   /** Reread tasks, plans, comments and metrics from disk (throttled unless forced). */
@@ -675,8 +667,6 @@ export class LobbyView implements Component, Focusable {
         return this.cycleTab(1);
       case "prevTab":
         return this.cycleTab(-1);
-      case "toggleScene":
-        return this.togglePanel("animations");
       case "toggleConversation":
         return this.togglePanel("conversation");
       case "toggleActivity":
@@ -827,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":
@@ -839,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;
@@ -854,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();
@@ -1651,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.
@@ -1989,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);
   }
 
   /**
@@ -2065,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"),
@@ -2295,7 +2299,7 @@ export class LobbyView implements Component, Focusable {
     if (entry.view.kind !== "here") return this.otherSessionBody(entry, width, height, theme, now);
     const talk = this.conversationFor(entry);
     return renderHome({
-      ...(zen.task ? { task: zen.task, scene: (w: number, h: number, animated: boolean) => this.host.scene(w, h, animated) } : {}),
+      ...(zen.task ? { task: zen.task } : {}),
       chat: talk.chat,
       ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       ...(feed.reply ? { liveReply: feed.reply } : {}),
@@ -2313,7 +2317,6 @@ export class LobbyView implements Component, Focusable {
       panels: this.panels,
       ...(query ? { query } : {}),
       keys: {
-        animations: keyLabel(this.keys.toggleScene),
         conversation: keyLabel(this.keys.toggleConversation),
         activity: keyLabel(this.keys.toggleActivity),
         thinking: keyLabel(this.keys.toggleThinking),
@@ -2323,8 +2326,7 @@ export class LobbyView implements Component, Focusable {
 
   /**
    * Another session on the Lobby tab: a background session's live feed, or an
-   * other terminal's conversation read from its session file; the task's
-   * status sits on top without animations.
+   * other terminal's conversation read from its session file.
    */
   private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
     const session = this.viewedSession();
@@ -2332,7 +2334,7 @@ export class LobbyView implements Component, Focusable {
     const task = entry.task;
     const query = this.query();
     const common = {
-      ...(task ? { task, scene: (w: number, h: number) => this.host.taskScene(task, w, h), stillScene: true } : {}),
+      ...(task ? { task } : {}),
       others: 0,
       pending: 0,
       offsets: this.homeOffsets,
@@ -2345,7 +2347,6 @@ export class LobbyView implements Component, Focusable {
       ...(query ? { query } : {}),
       title: entry.name,
       keys: {
-        animations: keyLabel(this.keys.toggleScene),
         conversation: keyLabel(this.keys.toggleConversation),
         activity: keyLabel(this.keys.toggleActivity),
         thinking: keyLabel(this.keys.toggleThinking),

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/activity.ts

@@ -1,8 +1,6 @@
 /**
  * One-word descriptions of the tool an agent is running: subagents show it as
- * `[spinner] word - elapsed`, and the oracle names the master's `orchestrate`
- * action. Pure lookup:
- * no clock, environment or I/O reads.
+ * `[spinner] word - elapsed`. Pure lookup: no clock, environment or I/O reads.
  */
 const ACTIVITY_WORDS: Record<string, string> = {
   read: "reading",
@@ -22,46 +20,16 @@ const ACTIVITY_WORDS: Record<string, string> = {
 
 const FALLBACK_WORD = "working";
 
-/** What the oracle says between its own tool calls while a master turn runs. */
-export const ORACLE_THINKING = "thinking";
-
 export function activityWord(toolName: string): string {
   return ACTIVITY_WORDS[toolName.trim().toLowerCase()] ?? FALLBACK_WORD;
 }
 
-/** Master `orchestrate` actions -> the word the oracle shows instead of the generic "orchestrating". */
-const ORACLE_ACTION_WORDS: Record<string, string> = {
-  clarify: "asking",
-  scout: "scouting",
-  research: "researching",
-  propose: "proposing",
-  plan: "planning",
-  implement: "delegating",
-  qa: "reviewing",
-  knowledge: "recording",
-  compact: "recording",
-  decide: "deciding",
-  resolve_approval: "deciding",
-  complete: "wrapping up",
-  status: "checking",
-  block: "blocking",
-  resume: "resuming",
-  cancel: "cancelling",
-};
-
 function orchestrateAction(args: unknown): string | undefined {
   if (!args || typeof args !== "object" || !("action" in args)) return undefined;
   const action = (args as { action?: unknown }).action;
   return typeof action === "string" ? action.trim().toLowerCase() : undefined;
 }
 
-/** One word for what the oracle (master) is doing; `orchestrate` maps by its action. */
-export function oracleActivityWord(toolName: string, args?: unknown): string {
-  if (toolName.trim().toLowerCase() !== "orchestrate") return activityWord(toolName);
-  const action = orchestrateAction(args);
-  return (action && ORACLE_ACTION_WORDS[action]) || FALLBACK_WORD;
-}
-
 const DETAIL_CHARS = 28;
 
 function clip(text: string): string {

package/src/pi/events.ts

@@ -7,8 +7,8 @@ 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 { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity } from "./ui.ts";
-import { ORACLE_THINKING, oracleActivityWord } from "./activity.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";
 import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
@@ -65,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) => {
@@ -76,26 +77,16 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
 
 
-  // The oracle's speech bubble mirrors the master's own turn: thinking between
-  // tool calls, the tool's word during one, and silent (your turn) once it ends.
-  // Subagents report into runs instead.
-  // Parallel tool calls: the newest still-running call keeps the word.
-  const inFlight = new Map<string, string>();
-  const showOracle = () => setOracleActivity([...inFlight.values()].at(-1) ?? ORACLE_THINKING);
   // A task's time budget counts while the oracle works on it, not while it waits on the user.
   const asking = new Set<string>();
   pi.on("agent_start", (_event, ctx) => {
     if (isSubagentProcess()) return;
-    inFlight.clear();
-    showOracle();
     const root = detectProjectRoot(ctx.cwd, configDir);
     const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
     if (task) startClock(root, configDir, task.id);
   });
   pi.on("tool_execution_start", (event) => {
     if (isSubagentProcess()) return;
-    inFlight.set(event.toolCallId, oracleActivityWord(event.toolName, event.args));
-    showOracle();
     if (ASKING_TOOLS.has(event.toolName) && !asking.has(event.toolCallId)) {
       asking.add(event.toolCallId);
       pauseClocks();
@@ -103,14 +94,10 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
   pi.on("tool_execution_end", (event) => {
     if (isSubagentProcess()) return;
-    inFlight.delete(event.toolCallId);
-    showOracle();
     if (asking.delete(event.toolCallId)) resumeClocks();
   });
   pi.on("agent_end", () => {
     if (isSubagentProcess()) return;
-    inFlight.clear();
-    setOracleActivity(undefined);
     for (const _call of asking) resumeClocks();
     asking.clear();
     stopClocks();

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. */