@a-t-h-i/bot-lobby 0.6.13 → 0.6.15

package/src/lobby/service.ts

@@ -1,13 +1,12 @@
 /**
- * The lobby's backend, without the terminal: every host member the view
- * needs that does not draw anything. `createLobbyService(state)` builds it
- * from the same state the terminal lobby runs on, so a later web server can
- * drive the lobby through this module without a TUI. Putting a question on
- * screen stays with the terminal; the dialog data and its answer live here.
+ * The lobby's backend: `createLobbyService(state)` builds the service the web
+ * server drives from the runtime's state. Questions go to the page through
+ * the prompt hub (see ../ask/web.ts).
  */
 import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { loadTask, peekTasks } from "../state/persistence.ts";
+import { releaseAttachments } from "../state/attachments.ts";
 import { loadConfig, saveConfig as writeConfig } from "../state/project.ts";
 import { addPlanComment, readPlanComments } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
@@ -16,7 +15,7 @@ import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
 import { readClassifierMetrics, readMetrics } from "../state/metrics.ts";
-import { currentZenTask, isMinimized, taskSnapshot } from "../pi/ui.ts";
+import { currentZenTask, taskSnapshot } from "../pi/ui.ts";
 import { taskName } from "../text.ts";
 import { describeWorkspace } from "../execution/workspace.ts";
 import { stripStartFlags } from "../pi/start-flags.ts";
@@ -29,21 +28,18 @@ import { chatFromEntries, lobbyFeed, type ChatEntry } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type DialogAnswer, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
-import { answerMessage, askUser, questionnaires, settledQuestions, type Asker } from "./ask.ts";
+import { answerMessage, questionnaires, settledQuestions } from "./ask.ts";
+import { askUser } from "../ask/web.ts";
+import type { Asker } from "../ask/types.ts";
 import { PlanningSession, type PlannerSeed } from "./planner.ts";
+import { applyMasterModel } from "../pi/model-settings.ts";
 import { lobbyTopics } from "./topics.ts";
-import { promptHub } from "./prompt-hub.ts";
 import { checkSession } from "../excalidraw/check.ts";
 import type { LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
-import type { LiveSession, LobbyHost, SwitchTarget } from "./view.ts";
+import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
+import { pushNotice, type NoticeLevel } from "../webui/notices.ts";
 import type { Runtime } from "./runtime.ts";
 
-/**
- * The lobby without its terminal-only members (rows, theme, hide,
- * requestRender, now, keys, panels, savePanels, editText, openSettings).
- */
-export type LobbyService = Omit<LobbyHost, "rows" | "theme" | "hide" | "requestRender" | "now" | "keys" | "panels" | "savePanels" | "editText" | "openSettings">;
-
 /** The state background callbacks report to; set while the lobby service runs. */
 let serviceState: Runtime | undefined;
 
@@ -52,36 +48,14 @@ export function setServiceState(state: Runtime | undefined): void {
   serviceState = state;
 }
 
-/** Repaints asked for by what happens in the background come at most this often. */
-export const FRAME_MS = 40;
-let lastFrame = 0;
-let frameTimer: ReturnType<typeof setTimeout> | undefined;
-
 /**
- * Repaint the lobby for something that happened in the background. A reply
- * streams dozens of events a second; they share frames, at most one per
- * `FRAME_MS`, instead of each asking for its own. Keys repaint at once
- * through pi.
+ * Tell the user: a toast in the page, and in pi's own terminal too when it is
+ * a warning or an error (the page may not be open).
  */
-export function repaintLobby(): void {
-  const state = serviceState;
-  // Hidden, only the one-line status under the editor changes.
-  if (!state || (!state.visible && !miniShown(state)) || frameTimer) return;
-  const wait = lastFrame + FRAME_MS - Date.now();
-  const paint = () => {
-    frameTimer = undefined;
-    lastFrame = Date.now();
-    const current = serviceState;
-    if (current?.visible || (current && miniShown(current))) current.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. */
-export function miniShown(state: Runtime): boolean {
-  return !state.visible && !isMinimized() && loadConfig().lobby.miniLine;
+export function lobbyNotify(state: Runtime, message: string, level: "info" | "warning" | "error" = "info"): void {
+  lobbyTopics.bump("notices");
+  pushNotice(message, level as NoticeLevel);
+  if (level !== "info") state.ctx.ui.notify(message, level);
 }
 
 function sessionModel(ctx: ExtensionContext): string | undefined {
@@ -92,7 +66,7 @@ export function lobbyProfile(state: Runtime, kind: LobbyAgentKind) {
   return resolveLobbyProfile(loadConfig(), kind, {
     lookup: modelLookup(state.ctx),
     sessionModel: sessionModel(state.ctx),
-    warn: (message) => state.ctx.ui.notify(message, "warning"),
+    warn: (message) => lobbyNotify(state, message, "warning"),
   });
 }
 
@@ -118,15 +92,14 @@ function addComment(state: Runtime, taskId: string, text: string): string {
 
 function failed(state: Runtime, what: string, error: Error): void {
   lobbyFeed.log("LOBBY", `${what} — ${error.message}`, "error");
-  lobbyTopics.bump("notices");
-  state.ctx.ui.notify(`bot-lobby: ${what} — ${error.message}`, "error");
+  lobbyNotify(state, `bot-lobby: ${what} — ${error.message}`, "error");
 }
 
 function toOracle(state: Runtime, text: string): string | undefined {
   const busy = !state.ctx.isIdle();
   if (text.startsWith("/")) {
     state.pi.sendUserMessage(text, { expandPromptTemplates: true, ...(busy ? { deliverAs: "followUp" as const } : {}) });
-    return `sent ${text.split(/\s+/)[0]} to pi (built-in commands need the lobby hidden: alt+l)`;
+    return `sent ${text.split(/\s+/)[0]} to pi`;
   }
   // While the oracle decides where a request goes, what the user types joins that conversation.
   if (!currentZenTask() && !pendingRequest()) {
@@ -143,9 +116,7 @@ function startPlanned(state: Runtime, plan: PlannedTask): string {
   startPlannedTask(state.pi, state.ctx, state.configDir, plan.id)
     .then((task) => {
       if (typeof task === "string") return failed(state, `could not start ${plan.id}`, new Error(task));
-      state.view?.setTab("lobby");
       lobbyTopics.bump("tasks");
-      repaintLobby();
     })
     .catch((error: Error) => failed(state, `could not start ${plan.id}`, error));
   return `starting ${plan.id} here — its agreed plan needs no approval…`;
@@ -167,10 +138,7 @@ const chats = new SessionChats(async () => {
   if (!dirs.has(state.root)) dirs.set(state.root, undefined);
   const lists = await Promise.all([...dirs].map(([cwd, dir]) => SessionManager.list(cwd, dir).catch(() => [])));
   return lists.flat();
-}, () => {
-  lobbyTopics.bump("sessions");
-  repaintLobby();
-});
+}, () => lobbyTopics.bump("sessions"));
 
 /** Launch background sessions with something else (tests); resets the registry. */
 export function setSessionLauncher(next: SessionLauncher | undefined): void {
@@ -199,7 +167,7 @@ export function backgroundSessions(): readonly BackgroundSession[] {
   return registry?.sessions ?? [];
 }
 
-/** A background session changed: redraw, and say so when one asks something or fails while the lobby is hidden. */
+/** A background session changed: say so when one asks something or fails. */
 function sessionsChanged(): void {
   lobbyTopics.bump("sessions");
   const state = serviceState;
@@ -207,20 +175,13 @@ function sessionsChanged(): void {
     if (session.sessionId && session.sessionFile) chats.remember(session.sessionId, session.sessionFile);
     const seen = announced.get(session.key) ?? 0;
     announced.set(session.key, session.dialogs.length);
-    if (!state || state.visible) continue;
-    if (session.dialogs.length > seen) {
-      lobbyTopics.bump("notices");
-      state.ctx.ui.notify(`bot-lobby: ${session.name} is waiting for you — alt+l opens the lobby`, "info");
-    }
+    if (!state) continue;
+    if (session.dialogs.length > seen) lobbyNotify(state, `bot-lobby: ${session.name} is waiting for you — see the Sessions page`, "info");
     if (!session.alive && !exitsSaid.has(session.key)) {
       exitsSaid.add(session.key);
-      if (session.exitCode) {
-        lobbyTopics.bump("notices");
-        state.ctx.ui.notify(`bot-lobby: ${session.name} exited (${session.exitCode})${session.lastError() ? `: ${session.lastError()}` : ""}`, "warning");
-      }
+      if (session.exitCode) lobbyNotify(state, `bot-lobby: ${session.name} exited (${session.exitCode})${session.lastError() ? `: ${session.lastError()}` : ""}`, "warning");
     }
   }
-  repaintLobby();
 }
 
 /** Start a task in its own new pi session, named after the task; the session, or why not. */
@@ -245,39 +206,6 @@ function startSession(state: Runtime, start: { request?: string; plan?: PlannedT
   }
 }
 
-/** The oldest question a background session waits on, if any (data only; the terminal draws it). */
-export function peekSessionDialog(session: BackgroundSession) {
-  return session.dialogs[0];
-}
-
-/** Answer a background session's dialog (data only; the terminal draws it). */
-export function answerSessionDialog(session: BackgroundSession, id: string, answer: DialogAnswer): void {
-  session.answer(id, answer);
-}
-
-/** Put the oldest question a background session waits on to the user, with pi's own dialogs; escape cancels it as it would there. */
-async function answerDialog(state: Runtime, session: BackgroundSession): Promise<void> {
-  const dialog = peekSessionDialog(session);
-  if (!dialog) return;
-  const title = `${session.name} — ${dialog.title}`;
-  const ui = state.ctx.ui;
-  try {
-    await promptHub.run("sessionDialog", session.name, { dialog }, async () => {
-      if (dialog.method === "select") {
-        const value = await ui.select(title, dialog.options ?? []);
-        answerSessionDialog(session, dialog.id, value === undefined ? { cancelled: true } : { value });
-      } else if (dialog.method === "confirm") {
-        answerSessionDialog(session, dialog.id, { confirmed: await ui.confirm(title, dialog.message ?? "") });
-      } else {
-        const value = dialog.method === "input" ? await ui.input(title, dialog.placeholder) : await ui.editor(title, dialog.prefill);
-        answerSessionDialog(session, dialog.id, value === undefined ? { cancelled: true } : { value });
-      }
-    });
-  } catch (error) {
-    failed(state, `could not answer ${session.name}`, error as Error);
-  }
-}
-
 /** Leave a message for a task another terminal's session drives; its owner passes it to the oracle. */
 function sendToTask(state: Runtime, taskId: string, text: string): string {
   const task = loadTask(state.root, state.configDir, taskId);
@@ -350,16 +278,6 @@ function sendToSession(state: Runtime, sessionId: string, text: string): string
   return "sent — that session passes it to its oracle within a few seconds";
 }
 
-/** The lobby reopens on the session this window switches to (set just before asking pi to switch). */
-let reopenAfterSwitch = false;
-
-/** Whether a switch asked for from the lobby is still owed its reopen; clears the flag. */
-export function takeReopenAfterSwitch(): boolean {
-  const value = reopenAfterSwitch;
-  reopenAfterSwitch = false;
-  return value;
-}
-
 /**
  * Run another session in this window through `/bot-lobby switch`, which pi
  * runs with a command context (the only one that may replace the session).
@@ -367,9 +285,8 @@ export function takeReopenAfterSwitch(): boolean {
  * task no session owns is claimed instead.
  */
 async function switchTo(state: Runtime, target: SwitchTarget): Promise<string> {
-  if (!state.ctx.isIdle()) return "this window's oracle is working — esc stops it, then switch";
+  if (!state.ctx.isIdle()) return "this window's oracle is working — stop it, then switch";
   if (target.claimTaskId) {
-    reopenAfterSwitch = false;
     state.pi.sendUserMessage(`/bot-lobby claim ${target.claimTaskId}`, { expandPromptTemplates: true });
     return `taking ${target.claimTaskId} over in this window`;
   }
@@ -380,7 +297,6 @@ async function switchTo(state: Runtime, target: SwitchTarget): Promise<string> {
   }
   file ??= target.sessionId ? await chats.locate(target.sessionId) : undefined;
   if (!file) return `could not find ${target.name}'s session file — /resume lists every saved session`;
-  reopenAfterSwitch = true;
   state.pi.sendUserMessage(`/bot-lobby switch ${file}`, { expandPromptTemplates: true });
   return `switching this window to ${target.name}…`;
 }
@@ -390,7 +306,7 @@ function drivenElsewhere(state: Runtime, task: Task): string | undefined {
   if (TERMINAL_STATES.includes(task.state) || !task.ownerSessionId) return undefined;
   if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) return `this window drives ${task.id} — cancel it first (/bot-lobby cancel ${task.id})`;
   const background = backgroundSessions().find((session) => session.alive && session.sessionId === task.ownerSessionId);
-  if (background) return `${background.name} is driving ${task.id} in the background — stop it first (x x)`;
+  if (background) return `${background.name} is driving ${task.id} in the background — stop it first`;
   if (liveSessions(state).some((session) => session.sessionId === task.ownerSessionId)) return `a session in another terminal is driving ${task.id} — finish or cancel it there first`;
   return undefined;
 }
@@ -402,12 +318,13 @@ function archiveTask(state: Runtime, taskId: string): string {
   if (busy) return busy;
   try {
     archiveTaskOnDisk(state.root, state.configDir, taskId);
+    releaseAttachments(taskId);
   } catch (error) {
     return (error as Error).message;
   }
   lobbyFeed.log("LOBBY", `archived ${taskId}`, "info");
   lobbyTopics.bump("tasks");
-  return `archived ${taskId}${TERMINAL_STATES.includes(task.state) ? "" : " (abandoned first)"} — v shows archived tasks, a restores one`;
+  return `archived ${taskId}${TERMINAL_STATES.includes(task.state) ? "" : " (abandoned first)"} — show archived tasks to restore it`;
 }
 
 function restoreTask(state: Runtime, taskId: string): string {
@@ -430,6 +347,7 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   }
   try {
     deleteTaskOnDisk(state.root, state.configDir, taskId, where);
+    releaseAttachments(taskId);
   } catch (error) {
     return (error as Error).message;
   }
@@ -443,7 +361,7 @@ export function reviewProfile(state: Runtime) {
   return resolveReviewProfile(loadConfig(), {
     lookup: modelLookup(state.ctx),
     sessionModel: sessionModel(state.ctx),
-    warn: (message) => state.ctx.ui.notify(message, "warning"),
+    warn: (message) => lobbyNotify(state, message, "warning"),
   });
 }
 
@@ -451,7 +369,7 @@ export function seatProfile(state: Runtime, member: PanelMember) {
   return resolvePanelProfile(loadConfig(), member, {
     lookup: modelLookup(state.ctx),
     sessionModel: sessionModel(state.ctx),
-    warn: (message) => state.ctx.ui.notify(message, "warning"),
+    warn: (message) => lobbyNotify(state, message, "warning"),
   });
 }
 
@@ -473,20 +391,13 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
-    onChange: () => {
-      lobbyTopics.bump("planner");
-      repaintLobby();
-    },
-    onRound: (session) => {
-      lobbyTopics.bump("planner");
-      // Put the questions to the user at once when they are looking at the Plan tab.
-      if (loadConfig().lobby.autoAsk && state.visible && state.view?.tab === "plan" && session.awaitingAnswers) void answerPanel(state);
-    },
+    onChange: () => lobbyTopics.bump("planner"),
+    onRound: () => lobbyTopics.bump("planner"),
   }, seed);
   return state.planner;
 }
 
-/** The questionnaire (pi's own dialogs where it cannot be drawn); tests swap it. */
+/** The questionnaire in the page; tests swap it. */
 function panelAsker(state: Runtime): Asker {
   return state.asker ?? askUser;
 }
@@ -504,10 +415,10 @@ export async function savePlan(state: Runtime | undefined): Promise<string> {
   state.asking = true;
   try {
     const asker = panelAsker(state);
-    return await session.saveWithSplit((questions, signal) => promptHub.run("questionnaire", "planner", { questions }, () => asker(questions, state.ctx, signal), { signal }), { splitAbove: loadConfig().lobby.splitPlanAbove });
+    return await session.saveWithSplit((questions, signal) => asker(questions, state.ctx, signal, "planner"), { splitAbove: loadConfig().lobby.splitPlanAbove });
   } finally {
     state.asking = false;
-    repaintLobby();
+    lobbyTopics.bump("planner");
   }
 }
 
@@ -529,10 +440,9 @@ export async function answerPanel(state: Runtime | undefined): Promise<string> {
     const chunks = questionnaires(session.questions);
     for (let index = session.answered.length; index < chunks.length; index++) {
       const questions = chunks[index]!;
-      const result = await promptHub.run("questionnaire", "planner", { questions }, () => asker(questions, state.ctx));
+      const result = await asker(questions, state.ctx, undefined, "planner");
       if (result.cancelled) {
-        repaintLobby();
-        return session.answered.length > 0 ? `answers kept — ${chunks.length - session.answered.length} questionnaire${chunks.length - session.answered.length === 1 ? "" : "s"} left; enter resumes` : "questions put away — enter brings them back";
+        return session.answered.length > 0 ? `answers kept — ${chunks.length - session.answered.length} questionnaire${chunks.length - session.answered.length === 1 ? "" : "s"} left; answer again to resume` : "questions put away — answer again to bring them back";
       }
       session.answered = [...session.answered, result];
     }
@@ -547,7 +457,7 @@ export async function answerPanel(state: Runtime | undefined): Promise<string> {
     return `could not put the questions: ${(error as Error).message}`;
   } finally {
     state.asking = false;
-    repaintLobby();
+    lobbyTopics.bump("planner");
   }
 }
 
@@ -560,7 +470,6 @@ function refreshWorkspace(state: Runtime): void {
       if (serviceState !== state || (info.name === state.workspace.name && info.branch === state.workspace.branch)) return;
       state.workspace = info;
       lobbyTopics.bump("status");
-      repaintLobby();
     })
     .catch(() => {})
     .finally(() => {
@@ -570,6 +479,11 @@ function refreshWorkspace(state: Runtime): void {
 
 /** The lobby's backend for `state`: every host member that draws nothing. */
 export function createLobbyService(state: Runtime): LobbyService {
+  const masterKey = () => {
+    const { master } = loadConfig();
+    return `${master.model}|${master.thinking}`;
+  };
+  let appliedMaster = masterKey();
   return {
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
@@ -600,8 +514,15 @@ export function createLobbyService(state: Runtime): LobbyService {
     planningRounds: () => loadConfig().lobby.maxPlanningRounds,
     config: () => loadConfig(),
     saveConfig: (next) => writeConfig(next),
-    configChanged: () => state.view?.reloadConfig(),
-    models: () => {
+    configChanged: () => {
+      lobbyTopics.bump("status");
+      // A new master model or effort takes hold in this session at once.
+      const next = masterKey();
+      if (next === appliedMaster) return;
+      appliedMaster = next;
+      void applyMasterModel(state.pi, state.ctx, loadConfig()).catch((error: Error) => lobbyNotify(state, `bot-lobby: could not apply the master model — ${error.message}`, "warning"));
+    },
+    sessionModel: () => sessionModel(state.ctx),    models: () => {
       try {
         const scoped = state.ctx.scopedModels;
         const usable = scoped.length > 0 ? scoped.map((entry) => entry.model) : state.ctx.modelRegistry.getAvailable();
@@ -637,7 +558,6 @@ export function createLobbyService(state: Runtime): LobbyService {
     sessionName: () => state.pi.getSessionName(),
     sessions: () => backgroundSessions(),
     startSession: (start) => startSession(state, start),
-    answerDialog: (session) => answerDialog(state, session),
     isAuto: (taskId) => autoFor(state, taskId),
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),

package/src/lobby/task-rows.ts

@@ -0,0 +1,28 @@
+/** The shapes of the Tasks tab's rows, shared by the web API and the page's words. */
+
+export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
+
+/** How a row is ticked off: still to do (a plan, or a task under way), completed, or abandoned. */
+export type CheckState = "open" | "done" | "dropped";
+
+export interface TaskRow {
+  /** A task on the list, a saved plan, or a task in the archive. */
+  kind: "task" | "plan" | "archived";
+  id: string;
+  title: string;
+  section: TaskSection;
+  /** Task state, or `pending` for a saved plan. */
+  status: string;
+  paused?: boolean;
+  check: CheckState;
+  /** Plan steps done, once the task has a plan. */
+  progress?: { done: number; total: number };
+  /** Who drives it, for tasks other sessions own. */
+  owner?: string;
+  /** How long ago it finished (finished tasks), was saved (plans) or was archived, as `3h`. */
+  age?: string;
+  /** The GitHub issue a plan came from. */
+  issue?: number;
+  /** Auto mode is on: the oracle drives it without asking. */
+  auto?: boolean;
+}

package/src/pi/commands.ts

@@ -19,12 +19,11 @@ import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
 import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAsks, waiveQa, type ApprovalChoice } from "../workflow/workflow.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
-import { classifierSummary, openSettings } from "./settings-ui.ts";
+import { classifierSummary } from "./model-settings.ts";
 import { keyStatus } from "../classifier/instance.ts";
 import { kickoff, startPlannedTask } from "./start-task.ts";
 import { startRequest } from "./route.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
-import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
 import { registerWebServer, webCommand } from "../webui/command.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
 import { describeRun, runFromLog } from "./run-summary.ts";
@@ -35,7 +34,7 @@ import type { GitIsolation } from "../schemas/configuration.ts";
 import { START_FLAG } from "./start-flags.ts";
 
 const HELP = [
-  "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
+  "/bot-lobby                  Open the web lobby in your browser: tasks, plan, quick fix, metrics",
   "/bot-lobby <request>        Start a request: a quick fix when one agent can do it alone (the oracle confirms), else a task",
   "/bot-lobby --task [--auto] <request>   Always a task (also when the request begins with a subcommand word)",
   "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
@@ -50,14 +49,14 @@ const HELP = [
   "/bot-lobby accept [taskId]  Accept a task's work as it is, without a QA pass; the oracle then completes it",
   "/bot-lobby knowledge        Show persistent knowledge files",
   "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
-  "/bot-lobby settings         Edit per-agent model/thinking/instructions",
+  "/bot-lobby settings         Open the web lobby's Settings: per-agent model, effort and instructions",
   "/bot-lobby config           Show effective configuration",
   "/bot-lobby minimize|restore   Hide or restore bot-lobby for this session (ctrl+shift+m)",
   "/bot-lobby claim <taskId>    Take ownership of an orphaned task",
   "/bot-lobby auto [on|off]    Auto mode: the oracle drives this session's task without asking (alt+g)",
   "/bot-lobby start-plan PLAN-… [auto]   Start a planned task here; its agreed plan needs no approval",
-  "/bot-lobby switch <session.jsonl>   Run a saved session in this window (the lobby's session browser uses it: alt+o, s)",
-  "/bot-lobby web [stop|link|reset]   Start the browser UI on this machine (loopback only), or stop it, print its link, reset its link",
+  "/bot-lobby switch <session.jsonl>   Run a saved session in this window (the web lobby's session browser uses it)",
+  "/bot-lobby web [stop|link|reset]   Open the browser UI (it starts with pi, on this machine only), or stop it, print its link, reset its link",
   "/bot-lobby help             This help",
 ].join("\n");
 
@@ -306,7 +305,7 @@ function showConfig(ctx: ExtensionCommandContext): void {
 async function switchCommand(ctx: ExtensionCommandContext, path: string): Promise<void> {
   if (!existsSync(path)) return ctx.ui.notify(`bot-lobby: no session file at ${path}`, "warning");
   if (ctx.sessionManager.getSessionFile() === path) return ctx.ui.notify("bot-lobby: this window already runs that session", "info");
-  if (!ctx.isIdle()) return ctx.ui.notify("bot-lobby: the oracle is working — esc stops it, then switch", "warning");
+  if (!ctx.isIdle()) return ctx.ui.notify("bot-lobby: the oracle is working — stop it, then switch", "warning");
   const result = await ctx.switchSession(path);
   if (result.cancelled) ctx.ui.notify("bot-lobby: the switch was cancelled", "warning");
 }
@@ -336,19 +335,14 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       const { sub, rest, restText, auto, budget, budgetError, track, task, isolation } = parseCommand(args ?? "");
       if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
-        if (!restText) {
-          if (!showLobby()) ctx.ui.notify(HELP, "info");
-          return;
-        }
+        if (!restText) return webCommand(ctx, undefined);
         // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
-        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
-        if (started === "task") autoOpenLobby();
+        await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
         return;
       }
       switch (sub) {
         case "lobby":
-          if (!showLobby()) ctx.ui.notify("The lobby needs pi's interactive terminal UI.", "warning");
-          return;
+          return webCommand(ctx, undefined);
         case "help":
           return ctx.ui.notify(HELP, "info");
         case "status":
@@ -376,7 +370,7 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
         case "knowledge":
           return showKnowledge(ctx, configDir);
         case "settings":
-          return openSettings(pi, ctx);
+          return webCommand(ctx, undefined);
         case "minimize":
           setMinimized(true);
           return applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir);
@@ -393,8 +387,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return webCommand(ctx, rest[0]);
         case "start-plan": {
           const started = await startPlannedTask(pi, ctx, configDir, rest[0]!, { auto: rest[1] === "auto" });
-          if (typeof started === "string") return ctx.ui.notify(`bot-lobby: ${started}`, "warning");
-          return autoOpenLobby();
+          if (typeof started === "string") ctx.ui.notify(`bot-lobby: ${started}`, "warning");
+          return;
         }
         default:
           return showConfig(ctx);
@@ -403,7 +397,7 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
   });
 
   pi.registerCommand("bot-lobby-settings", {
-    description: "Edit per-agent model, thinking, and instructions",
-    handler: async (_args, ctx) => openSettings(pi, ctx),
+    description: "Open the web lobby's settings: per-agent model, effort, and instructions",
+    handler: async (_args, ctx) => webCommand(ctx, undefined),
   });
 }

package/src/pi/model-settings.ts

@@ -0,0 +1,112 @@
+/**
+ * What the settings page writes to the config, in one place: a profile entry
+ * patched into a config copy, the master's model and thinking applied to the
+ * live session, the subagents pinned to the session model, and the
+ * classifier's one-line summary.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  INHERIT_MODEL,
+  isThinkingLevel,
+  SUBAGENT_KINDS,
+  type AgentModelConfig,
+  type BotLobbyConfig,
+  type SubagentKind,
+} from "../schemas/configuration.ts";
+import { modelLookup } from "./tools.ts";
+import { describeKey, jevEndpoint, type StatusSource } from "../classifier/hosts.ts";
+
+/** One settings entry: the master or a subagent profile. */
+export type SettingsKind = "master" | SubagentKind;
+export const SETTINGS_KINDS: readonly SettingsKind[] = ["master", ...SUBAGENT_KINDS];
+
+/** The editable fields of one entry; scouts have no thinking and no instructions of their own. */
+export interface EntryView {
+  model: string;
+  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;
+}
+
+export 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, ...(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;
+  return config.agents[kind];
+}
+
+interface EntryPatch {
+  model?: string;
+  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 = withFallbackPatch({ ...config.master, ...patch } as AgentModelConfig);
+  else if (kind === "scout") {
+    const fallbackModel = patch.fallbackModel ?? config.scout.fallbackModel;
+    next.scout = withFallbackPatch({
+      model: patch.model ?? config.scout.model,
+      timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs,
+      ...(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;
+}
+
+/** Apply the master model/thinking to the live session; "inherit" leaves it alone. */
+export async function applyMasterModel(pi: ExtensionAPI, ctx: ExtensionContext, config: BotLobbyConfig): Promise<void> {
+  const { model, thinking } = config.master;
+  if (model !== INHERIT_MODEL) {
+    const found = modelLookup(ctx)(model);
+    if (!found) ctx.ui.notify(`bot-lobby: unknown master model "${model}".`, "warning");
+    else if (!(await pi.setModel(found))) ctx.ui.notify(`bot-lobby: no auth for ${model}.`, "warning");
+  }
+  if (isThinkingLevel(thinking)) pi.setThinkingLevel(thinking);
+}
+
+/**
+ * Subagents never inherit silently: any subagent whose model is still unset is
+ * pinned to the session's current model and saved, so settings always show
+ * what each agent runs on.
+ */
+export function prefillModels(config: BotLobbyConfig, sessionModel: string | undefined): { config: BotLobbyConfig; filled: SubagentKind[] } {
+  if (!sessionModel) return { config, filled: [] };
+  let next = config;
+  const filled: SubagentKind[] = [];
+  for (const kind of SUBAGENT_KINDS) {
+    if (entryView(next, kind).model !== INHERIT_MODEL) continue;
+    next = patchEntry(next, kind, { model: sessionModel });
+    filled.push(kind);
+  }
+  return { config: next, filled };
+}
+
+/** `on · OpenCode Zen · jev-1.13-free · key stored in pi`, for the settings menu and `/bot-lobby config`. */
+export function classifierSummary(config: BotLobbyConfig, status: StatusSource | undefined): string {
+  const { host, model } = jevEndpoint(config.classifier, status);
+  const via = config.classifier.provider === "auto" ? `${host.label} (auto)` : host.label;
+  return [config.classifier.enabled ? "on" : "off", via, model, `key ${describeKey(host, status)}`].join(" · ");
+}
+

package/src/pi/start-task.ts

@@ -14,7 +14,7 @@ import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { transition } from "../state/task-state.ts";
 import { shortTitle } from "../text.ts";
 import { applyStatus } from "./ui.ts";
-import { applyMasterModel } from "./settings-ui.ts";
+import { applyMasterModel } from "./model-settings.ts";
 import { setAutoMode } from "../state/auto.ts";
 import { listPlannedTasks, loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest, type PlannedTask } from "../state/backlog.ts";
 import { triageFor } from "../classifier/instance.ts";