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

package/src/pi/commands.ts

@@ -26,7 +26,7 @@ import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
 
 const HELP = [
-  "/bot-lobby                  Open the lobby: tasks, plan, quick fix, issues, metrics (alt+l)",
+  "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
   "/bot-lobby <request>        Start a task through the workflow",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",

package/src/pi/settings-ui.ts

@@ -9,10 +9,12 @@ import { Container, type Component, type Focusable, fuzzyFilter, getKeybindings,
 import {
   INHERIT_MODEL,
   isThinkingLevel,
+  LOBBY_PANELS,
   SCOUT_THINKING,
   SUBAGENT_KINDS,
   type AgentModelConfig,
   type BotLobbyConfig,
+  type LobbyPanel,
   type SubagentKind,
 } from "../schemas/configuration.ts";
 import { globalConfigPath, loadConfig, saveConfig } from "../state/project.ts";
@@ -314,6 +316,15 @@ async function editEntry(pi: ExtensionAPI, ctx: ExtensionContext, kind: Settings
   }
 }
 
+/** One agent's settings on their own: the lobby's Quick fix and Plan tabs open their agent's entry directly. */
+export async function openEntrySettings(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify(`bot-lobby settings live in ${globalConfigPath()}; edit that file outside the TUI.`, "info");
+    return;
+  }
+  await editEntry(pi, ctx, kind);
+}
+
 /**
  * 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
@@ -338,6 +349,57 @@ function entryDescription(kind: SettingsKind, view: EntryView): string {
   return `${view.model} · ${thinking}${limit}${custom}`;
 }
 
+/** 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}`;
+
+const PANEL_SWITCH_LABELS: Record<LobbyPanel, string> = { scene: "Zen scene pane", conversation: "Conversation pane", activity: "Activity log pane", thinking: "Thinking pane" };
+
+export const LOBBY_SWITCHES: ReadonlyArray<{ id: LobbySwitch; label: string; help: string }> = [
+  { 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: "issues", label: "Issues tab", help: "the GitHub Issues tab" },
+  ...LOBBY_PANELS.map((panel) => ({ id: `panel:${panel}` as const, label: PANEL_SWITCH_LABELS[panel], help: "shown on the Lobby tab; its key in the lobby toggles it too" })),
+];
+
+export function lobbySwitch(config: BotLobbyConfig, id: LobbySwitch): boolean {
+  if (id.startsWith("panel:")) return config.lobby.panels[id.slice("panel:".length) as LobbyPanel];
+  return config.lobby[id as Exclude<LobbySwitch, `panel:${string}`>];
+}
+
+/** The config with one lobby setting flipped. */
+export function toggleLobbySwitch(config: BotLobbyConfig, id: LobbySwitch): BotLobbyConfig {
+  const value = !lobbySwitch(config, id);
+  if (id.startsWith("panel:")) {
+    const panel = id.slice("panel:".length) as LobbyPanel;
+    return { ...config, lobby: { ...config.lobby, panels: { ...config.lobby.panels, [panel]: value } } };
+  }
+  return { ...config, lobby: { ...config.lobby, [id]: value } };
+}
+
+/** On/off settings for the lobby; enter flips one and saves it. Key rebinding stays in the file (lobby.keys). */
+async function editLobby(ctx: ExtensionContext): Promise<void> {
+  for (;;) {
+    const config = loadConfig();
+    const items: SelectItem[] = LOBBY_SWITCHES.map((entry) => ({ value: entry.id, label: entry.label, description: `${lobbySwitch(config, entry.id) ? "on" : "off"} · ${entry.help}` }));
+    items.push({ value: "back", label: "Back", description: `keys: lobby.keys in ${globalConfigPath()}` });
+    const choice = await pick(ctx, "bot-lobby settings · Lobby", items);
+    if (!choice || choice === "back") return;
+    saveConfig(toggleLobbySwitch(config, choice as LobbySwitch));
+  }
+}
+
+function lobbySummary(config: BotLobbyConfig): string {
+  const hidden = LOBBY_PANELS.filter((panel) => !config.lobby.panels[panel]);
+  return [
+    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.issues ? ["issues tab"] : []),
+    ...(hidden.length > 0 ? [`hidden: ${hidden.join(", ")}`] : []),
+  ].join(" · ");
+}
+
 /** Open the per-agent settings editor; every change is written to the global config. */
 export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
   if (ctx.mode !== "tui") {
@@ -352,9 +414,11 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
   for (;;) {
     const config = loadConfig();
     const items: SelectItem[] = SETTINGS_KINDS.map((kind) => ({ value: kind, label: kindLabel(kind), description: entryDescription(kind, entryView(config, kind)) }));
+    items.push({ value: "lobby", label: "Lobby", description: lobbySummary(config) });
     items.push({ value: "close", label: "Close" });
     const choice = await pick(ctx, "bot-lobby settings", items);
     if (!choice || choice === "close") return;
-    await editEntry(pi, ctx, choice as SettingsKind);
+    if (choice === "lobby") await editLobby(ctx);
+    else await editEntry(pi, ctx, choice as SettingsKind);
   }
 }

package/src/schemas/configuration.ts

@@ -83,12 +83,26 @@ export function isPanelMember(value: string): value is PanelMember {
   return (PANEL_MEMBERS as readonly string[]).includes(value);
 }
 
+/** Lobby panes that can be shown or hidden (the Lobby tab's scene, conversation, activity log and thinking). */
+export const LOBBY_PANELS = ["scene", "conversation", "activity", "thinking"] as const;
+export type LobbyPanel = (typeof LOBBY_PANELS)[number];
+
 /** The full-screen lobby. */
 export interface LobbyConfig {
   /** Open by itself when this session starts or resumes a task. */
   autoOpen: boolean;
   /** Who sits on the planning panel next to the oracle, until toggled in the Plan tab. */
   planningPanel: PanelMember[];
+  /** Put the panel's questions to the user as soon as a round ends, while the Plan tab is open. */
+  autoAsk: boolean;
+  /** Show the GitHub Issues tab (off for now). */
+  issues: boolean;
+  /** Which panes show; toggled with keys in the lobby and remembered here. */
+  panels: Record<LobbyPanel, boolean>;
+  /** Key overrides by action name, e.g. `{ "toggleThinking": "alt+t" }`. */
+  keys: Record<string, string>;
+  /** Clicks and the wheel work in the lobby (click a draft line to comment on it); shift+drag still selects text. */
+  mouse: boolean;
 }
 
 export interface BotLobbyConfig {
@@ -135,7 +149,15 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     scratchpadMaxParagraphs: 4,
     scratchpadMaxChars: 2000,
   },
-  lobby: { autoOpen: true, planningPanel: [...PANEL_MEMBERS] },
+  lobby: {
+    autoOpen: true,
+    planningPanel: [...PANEL_MEMBERS],
+    autoAsk: true,
+    issues: false,
+    panels: { scene: true, conversation: true, activity: true, thinking: true },
+    keys: {},
+    mouse: true,
+  },
 };
 
 function positive(value: unknown): number | undefined {
@@ -159,14 +181,26 @@ function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig
   };
 }
 
+function flag(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
 function normalizeLobby(value: unknown): LobbyConfig {
-  const source = value as { autoOpen?: unknown; planningPanel?: unknown } | undefined;
+  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: 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)))]
-    : [...DEFAULT_CONFIG.lobby.planningPanel];
+    : [...defaults.planningPanel];
+  const panels = (source?.panels ?? {}) as Partial<Record<LobbyPanel, unknown>>;
+  const keys = source?.keys && typeof source.keys === "object" ? source.keys as Record<string, unknown> : {};
   return {
-    autoOpen: typeof source?.autoOpen === "boolean" ? source.autoOpen : DEFAULT_CONFIG.lobby.autoOpen,
+    autoOpen: flag(source?.autoOpen, defaults.autoOpen),
     planningPanel: PANEL_MEMBERS.filter((member) => panel.includes(member)),
+    autoAsk: flag(source?.autoAsk, defaults.autoAsk),
+    issues: flag(source?.issues, defaults.issues),
+    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),
   };
 }