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

package/src/lobby/topics.ts

@@ -0,0 +1,78 @@
+/**
+ * Every lobby change routed through one versioned emitter. Each topic carries
+ * a version that only grows; a later web server follows them over SSE, while
+ * the terminal subscribes to everything and repaints, exactly as before.
+ * Dependency-free on purpose: sources bump without importing the terminal.
+ */
+
+export const LOBBY_TOPICS = [
+  "lobby",
+  "tasks",
+  "plans",
+  "planner",
+  "quickfix",
+  "sessions",
+  "metrics",
+  "git",
+  "issues",
+  "knowledge",
+  "excalidraw",
+  "prompts",
+  "notices",
+  "status",
+] as const;
+
+export type LobbyTopic = (typeof LOBBY_TOPICS)[number];
+
+/** A change on `topic`, now at `version`. */
+export type LobbyTopicListener = (topic: LobbyTopic, version: number) => void;
+
+function isTopic(value: string): value is LobbyTopic {
+  return (LOBBY_TOPICS as readonly string[]).includes(value);
+}
+
+/** One version per topic; listeners hear every bump in order. */
+export class LobbyTopics {
+  private readonly versionsByTopic = new Map<LobbyTopic, number>();
+  private readonly listeners = new Set<LobbyTopicListener>();
+
+  /** The current version of `topic` (0 when nothing bumped it yet). */
+  version(topic: LobbyTopic): number {
+    return this.versionsByTopic.get(topic) ?? 0;
+  }
+
+  /** Every topic with its current version. */
+  versions(): Record<LobbyTopic, number> {
+    const snapshot = {} as Record<LobbyTopic, number>;
+    for (const topic of LOBBY_TOPICS) snapshot[topic] = this.version(topic);
+    return snapshot;
+  }
+
+  /** Record a change on `topic` and tell every listener. */
+  bump(topic: LobbyTopic): number {
+    if (!isTopic(topic)) return 0;
+    const version = this.version(topic) + 1;
+    this.versionsByTopic.set(topic, version);
+    for (const listener of [...this.listeners]) listener(topic, version);
+    return version;
+  }
+
+  /** Hear every bump; returns the unsubscribe function. */
+  subscribe(listener: LobbyTopicListener): () => void {
+    this.listeners.add(listener);
+    return () => this.unsubscribe(listener);
+  }
+
+  /** Stop hearing bumps. */
+  unsubscribe(listener: LobbyTopicListener): void {
+    this.listeners.delete(listener);
+  }
+
+  /** The terminal's subscription: every topic repaints, as before. */
+  onChange(listener: () => void): () => void {
+    return this.subscribe(() => listener());
+  }
+}
+
+/** The process-wide topics; every lobby source bumps these. */
+export const lobbyTopics = new LobbyTopics();

package/src/lobby/view.ts

@@ -16,15 +16,15 @@ import type { AgentRun } from "../schemas/findings.ts";
 import type { PlannedTask } from "../state/backlog.ts";
 import type { PlanComment } from "../state/comments.ts";
 import { aggregateMetrics, collectMetrics, SORT_KEYS, sortGroups, summarizeClassifier, taskStats, taskTimesByModel, type GroupBy, type MetricRecord, type SortKey } from "../state/metrics.ts";
-import { PANEL_MEMBERS, type LobbyAgentKind, type LobbyPanel, type PanelMember } from "../schemas/configuration.ts";
+import { PANEL_MEMBERS, type BotLobbyConfig, type LobbyAgentKind, type LobbyPanel, type PanelMember } from "../schemas/configuration.ts";
 import type { ChatEntry, LobbyFeed } from "./feed.ts";
 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, BRANCH_GLYPH, bold, box, fit, highlight, pageStep, pagerButton, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneBox, type PaneLayout, type PaneMark } from "./layout.ts";
+import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, tabJumpKey, type KeyMap, type LobbyAction } from "./keys.ts";
+import { beside, BRANCH_GLYPH, bold, box, fit, highlight, pageStep, pagerButton, paint, rule, selectRow, spinner, spread, windowStart, 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";
@@ -43,25 +43,10 @@ import { filterRecords, renderMetrics } from "./tabs/metrics.ts";
 /** The mark before a branch name in the title (shared with the task details). */
 export { BRANCH_GLYPH };
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "issues", "metrics", "git", "knowledge", "excalidraw"] as const;
-export type TabId = (typeof TAB_IDS)[number];
-
-export const TAB_LABELS: Record<TabId, string> = {
-  lobby: "Lobby",
-  tasks: "Tasks",
-  plan: "Plan",
-  quickfix: "Quick fix",
-  issues: "Issues",
-  metrics: "Metrics",
-  git: "Git",
-  knowledge: "Knowledge",
-  excalidraw: "Excalidraw",
-};
-
-/** The tabs on show: Issues only while `lobby.issues` switches it on. */
-export function visibleTabs(issues: boolean): TabId[] {
-  return TAB_IDS.filter((tab) => issues || tab !== "issues");
-}
+export { TAB_IDS, TAB_LABELS, visibleTabs } from "./prompts.ts";
+export type { TabId } from "./prompts.ts";
+// Local bindings for the uses below; the definitions live in prompts.ts.
+import { TAB_LABELS, visibleTabs, type TabId } from "./prompts.ts";
 
 /** Tabs where the prompt is the point: they open in typing mode and typing in browsing mode resumes it. */
 const PROMPT_FIRST: ReadonlySet<TabId> = new Set(["lobby", "plan", "quickfix"]);
@@ -135,6 +120,13 @@ export const OLDER_NOTE = "↑ earlier messages load as you scroll up";
 const SECTION_OF: Record<SessionWhere, string> = { "this window": "THIS WINDOW", background: "BACKGROUND", "other terminal": "OTHER TERMINALS", "not running": "NOT RUNNING" };
 const WHERE_MARKS: Record<SessionWhere, string> = { "this window": "●", background: "◆", "other terminal": "◇", "not running": "○" };
 
+/** One model Pi offers, for the settings page's picker: `provider/id`, its label and thinking levels. */
+export interface ModelChoice {
+  id: string;
+  label: string;
+  thinkingLevels: string[];
+}
+
 /** Everything the view needs from pi and bot-lobby. */
 export interface LobbyHost {
   rows(): number;
@@ -184,6 +176,14 @@ export interface LobbyHost {
   checkExcalidraw(session: ExcalidrawSession): Promise<SessionCheck>;
   /** Edit a text in pi's multi-line editor (the lobby steps aside meanwhile); the new text, or undefined when cancelled. */
   editText(title: string, text: string): Promise<string | undefined>;
+  /** The effective config, never a secret; the web settings page reads it. */
+  config?(): BotLobbyConfig;
+  /** Save a whole config, the way the settings menu does; the web settings page writes it. */
+  saveConfig?(config: BotLobbyConfig): void;
+  /** Reload cached config (keys, panes) after a settings change. */
+  configChanged?(): void;
+  /** The models Pi offers, for the settings page's picker. */
+  models?(): ModelChoice[];
   /** The Issues tab is switched on (`lobby.issues`). */
   issuesEnabled(): boolean;
   /** Which panes show (`lobby.panels`), and remembering a change. */
@@ -719,7 +719,7 @@ export class LobbyView implements Component, Focusable {
     if (action) return this.runAction(action);
     const tabs = this.tabs();
     for (const [index, tab] of tabs.entries()) {
-      if (matchesKey(data, Key.alt(String(index + 1) as "1"))) return this.setTab(tab);
+      if (matchesKey(data, tabJumpKey(index))) return this.setTab(tab);
     }
     if (matchesKey(data, Key.ctrl("c"))) {
       if (this.editor.getText()) return this.editor.setText("");
@@ -804,7 +804,12 @@ export class LobbyView implements Component, Focusable {
     if (matchesKey(data, Key.left) || matchesKey(data, Key.right)) return this.movePaneFocus(matchesKey(data, Key.left) ? -1 : 1);
     if (matchesKey(data, Key.home) || matchesKey(data, Key.end)) return this.scrollToEdge(matchesKey(data, Key.home));
     const tabs = this.tabs();
-    if (!PROMPT_FIRST.has(this.tab) && /^[1-9]$/.test(data) && Number(data) <= tabs.length) return this.setTab(tabs[Number(data) - 1]!);
+    const digit = /^[1-9]$/.test(data) ? Number(data) - 1 : -1;
+    if (!PROMPT_FIRST.has(this.tab) && digit >= 0 && digit < tabs.length) {
+      // Plain digits jump without Alt; the Alt key stays the shared definition.
+      void tabJumpKey(digit);
+      return this.setTab(tabs[digit]!);
+    }
     if (data === "i" && this.tab !== "metrics" && this.tab !== "tasks" && this.tab !== "issues" && this.tab !== "git" && this.tab !== "knowledge" && this.tab !== "excalidraw") return this.setMode("type");
     if (this.tabCommand(data)) return;
     const printable = isPrintable(data);

package/src/pi/commands.ts

@@ -25,6 +25,7 @@ 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";
 import { modelLookup } from "./tools.ts";
@@ -56,11 +57,12 @@ const HELP = [
   "/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 help             This help",
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch", "web"]);
 
 /** `Task-Change-Table-Font-27-09-2026`, or an older `TASK-add-login` id. */
 function isTaskId(value: string | undefined): boolean {
@@ -111,7 +113,8 @@ export function parseCommand(args: string): ParsedCommand {
     || (sub === "auto" && rest.length === 1 && /^(on|off)$/i.test(rest[0]!))
     || (sub === "budget" && rest.length >= 1 && rest.length <= 2 && (/^off$/i.test(rest[0]!) || parseMinutes(rest.join("")) !== undefined))
     || (sub === "start-plan" && rest.length >= 1 && rest.length <= 2 && /^PLAN-/.test(rest[0]!) && (rest.length === 1 || rest[1] === "auto"))
-    || (sub === "switch" && rest.length >= 1 && /\.jsonl$/.test(rest.join(" ")));
+    || (sub === "switch" && rest.length >= 1 && /\.jsonl$/.test(rest.join(" ")))
+    || (sub === "web" && rest.length === 1 && ["stop", "link", "reset"].includes(rest[0]!));
   if (!takesArgs && rest.length > 0 && !(rest.length === 1 && isTaskId(rest[0]))) {
     return { sub: undefined, rest: [], restText: trimmed };
   }
@@ -321,6 +324,7 @@ function autoCommand(ctx: ExtensionCommandContext, configDir: string, value: str
 
 export function registerCommands(pi: ExtensionAPI, configDir: string): void {
   registerRevealShortcut(pi, configDir);
+  registerWebServer(pi);
   pi.registerCommand("bot-lobby", {
     description: "Structured multi-agent engineering orchestrator",
     getArgumentCompletions: (prefix) => {
@@ -385,6 +389,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return autoCommand(ctx, configDir, rest[0]);
         case "switch":
           return switchCommand(ctx, restText);
+        case "web":
+          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");

package/src/pi/owner.ts

@@ -15,6 +15,7 @@ import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { commentMessage, markCommentsDelivered, readPlanComments, undeliveredComments } from "../state/comments.ts";
 import { inboxMessage, markInboxDelivered, markSessionInboxDelivered, readInbox, readSessionInbox } from "../state/inbox.ts";
 import { removePresence, writePresence } from "../state/presence.ts";
+import { currentWebServer } from "../webui/server.ts";
 import { isAutoMode, setAutoMode } from "../state/auto.ts";
 import { isSubagentProcess } from "./quiet.ts";
 import { isMinimized } from "./ui.ts";
@@ -119,6 +120,7 @@ export function heartbeat(): void {
       ...(name ? { name } : {}),
       ...(sessionFile ? { sessionFile } : {}),
       ...(live(task) ? { taskId: task.id } : {}),
+      ...(currentWebServer() ? { webPort: currentWebServer()!.port } : {}),
     });
   } catch {
     // A read-only project only means other windows do not see this one.

package/src/pi/settings-ui.ts

@@ -466,6 +466,55 @@ export function nextSplitLimit(current: number): number {
   return SPLIT_PLAN_CHOICES.find((choice) => choice > current) ?? 0;
 }
 
+/** `on · port 7347 · opens the browser · questions both`, for the settings menu. */
+export function webSummary(config: BotLobbyConfig): string {
+  const web = config.lobby.web;
+  return `${web.enabled ? "on" : "off"} · port ${web.port === 0 ? "any" : web.port} · ${web.openBrowser ? "opens the browser" : "link only"} · questions ${web.questions}`;
+}
+
+/** The next place the web UI's questions are answered (`both`, in the browser or the terminal). */
+export function nextWebQuestions(current: string): "both" | "terminal" {
+  return current === "both" ? "terminal" : "both";
+}
+
+/** A port typed in the settings menu: 0 (any free port) or a real port; undefined when it is not a port. */
+export function parseWebPort(typed: string): number | undefined {
+  if (!/^\d+$/.test(typed.trim())) return undefined;
+  const port = Number(typed.trim());
+  return port === 0 || (port > 0 && port <= 65535) ? port : undefined;
+}
+
+/** The loopback web UI's own settings: on/off, its port, the browser and where its questions are answered. */
+async function editWeb(ctx: ExtensionContext): Promise<void> {
+  const typed = await pick(ctx, "bot-lobby settings · Web UI", [
+    { value: "enabled", label: "Web UI", description: `${loadConfig().lobby.web.enabled ? "on" : "off"} · start the loopback browser UI with /bot-lobby web` },
+    { value: "port", label: "Port", description: `${loadConfig().lobby.web.port === 0 ? "any free port" : loadConfig().lobby.web.port} · the base port (then the next free up to +20); 0 means any free port` },
+    { value: "browser", label: "Open browser", description: `${loadConfig().lobby.web.openBrowser ? "on" : "off"} · open the link in the browser on /bot-lobby web` },
+    { value: "questions", label: "Questions", description: `${loadConfig().lobby.web.questions} · where the web UI's questions are answered: both, or the terminal only` },
+    { value: "back", label: "Back" },
+  ]);
+  if (!typed || typed === "back") return;
+  const config = loadConfig();
+  if (typed === "enabled") saveConfig({ ...config, lobby: { ...config.lobby, web: { ...config.lobby.web, enabled: !config.lobby.web.enabled } } });
+  else if (typed === "browser") saveConfig({ ...config, lobby: { ...config.lobby, web: { ...config.lobby.web, openBrowser: !config.lobby.web.openBrowser } } });
+  else if (typed === "questions") saveConfig({ ...config, lobby: { ...config.lobby, web: { ...config.lobby.web, questions: nextWebQuestions(config.lobby.web.questions) } } });
+  else await editWebPort(ctx);
+  await editWeb(ctx);
+}
+
+/** Type the web UI's port; 0 means any free port. */
+async function editWebPort(ctx: ExtensionContext): Promise<void> {
+  const typed = (await ctx.ui.input("Web UI port (0: any free port)", String(loadConfig().lobby.web.port)))?.trim();
+  if (!typed) return;
+  const port = parseWebPort(typed);
+  if (port === undefined) {
+    ctx.ui.notify(`bot-lobby: "${typed}" is not a port (0, or 1-65535).`, "warning");
+    return;
+  }
+  const config = loadConfig();
+  saveConfig({ ...config, lobby: { ...config.lobby, web: { ...config.lobby.web, port } } });
+}
+
 /** On/off settings for the lobby, and the planning round limit; enter flips or cycles one and saves it. Key rebinding stays in the file (lobby.keys). */
 async function editLobby(ctx: ExtensionContext): Promise<void> {
   for (;;) {
@@ -473,10 +522,12 @@ async function editLobby(ctx: ExtensionContext): Promise<void> {
     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: "rounds", label: "Planning rounds", description: `${roundLimitLabel(config.lobby.maxPlanningRounds)} · enter cycles 2, 3, 5, 8, unlimited; the last round the oracle settles alone` });
     items.push({ value: "split", label: "Split long plans", description: `${splitLimitLabel(config.lobby.splitPlanAbove)} · saving a plan with more steps offers to split it into up to 5 tasks · enter cycles 6, 8, 10, 12, never` });
+    items.push({ value: "web", label: "Web UI", description: webSummary(config) });
     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;
-    if (choice === "rounds") saveConfig({ ...config, lobby: { ...config.lobby, maxPlanningRounds: nextRoundLimit(config.lobby.maxPlanningRounds) } });
+    if (choice === "web") await editWeb(ctx);
+    else if (choice === "rounds") saveConfig({ ...config, lobby: { ...config.lobby, maxPlanningRounds: nextRoundLimit(config.lobby.maxPlanningRounds) } });
     else if (choice === "split") saveConfig({ ...config, lobby: { ...config.lobby, splitPlanAbove: nextSplitLimit(config.lobby.splitPlanAbove) } });
     else saveConfig(toggleLobbySwitch(config, choice as LobbySwitch));
   }

package/src/pi/tools.ts

@@ -10,6 +10,7 @@ import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { whileAsking } from "../state/budget.ts";
 import { askUser } from "../ask/dialog.ts";
+import { promptHub } from "../lobby/prompt-hub.ts";
 import type { AskQuestion } from "../ask/types.ts";
 import { unescapeBreaks } from "../lobby/markdown.ts";
 import { isQuiet } from "./quiet.ts";
@@ -126,10 +127,10 @@ export function workflowDeps(
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     // Time spent waiting on the user is not the task's: its budget clock waits too.
     // A free-text answer may run to several lines (Shift+Enter), so it is asked in the multi-line editor.
-    ask: async (question) => (hasUI ? whileAsking(() => ctx.ui.editor(question)) : undefined),
-    choose: async (title, options) => (hasUI ? whileAsking(() => ctx.ui.select(title, options)) : undefined),
+    ask: async (question) => (hasUI ? whileAsking(() => promptHub.run("text", "orchestrate", { question }, () => ctx.ui.editor(question))) : undefined),
+    choose: async (title, options) => (hasUI ? whileAsking(() => promptHub.run("choose", "orchestrate", { title, options }, () => ctx.ui.select(title, options))) : undefined),
     // An agent's own questions (the designer's), relayed as the questionnaire.
-    ...(hasUI ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),
+    ...(hasUI ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => promptHub.run("questionnaire", from, { questions }, () => askUser(questions, ctx, askSignal, from), askSignal ? { signal: askSignal } : undefined)) } : {}),
     notify: (message, level = "info") => {
       if (hasUI) ctx.ui.notify(message, level);
     },

package/src/schemas/configuration.ts

@@ -120,6 +120,21 @@ export function isPanelMember(value: string): value is PanelMember {
 export const LOBBY_PANELS = ["conversation", "activity", "thinking"] as const;
 export type LobbyPanel = (typeof LOBBY_PANELS)[number];
 
+/** Where the web UI's questions are answered: in the browser, or only in the terminal. */
+export const LOBBY_WEB_QUESTIONS = ["both", "terminal"] as const;
+export type LobbyWebQuestions = (typeof LOBBY_WEB_QUESTIONS)[number];
+
+/** The loopback web UI: off until started with `/bot-lobby web`. */
+export interface LobbyWebConfig {
+  /** Start the server with the session. */
+  enabled: boolean;
+  /** Base port (tried, then the next free up to +20); 0 means any free port. */
+  port: number;
+  /** Open the link in the browser on `/bot-lobby web`. */
+  openBrowser: boolean;
+  questions: LobbyWebQuestions;
+}
+
 /** The full-screen lobby. */
 export interface LobbyConfig {
   /** Open by itself when this session starts or resumes a task. */
@@ -148,6 +163,8 @@ export interface LobbyConfig {
    * tasks when it is saved (the oracle proposes, the user decides); 0 = never.
    */
   splitPlanAbove: number;
+  /** The loopback web UI (port, browser, where its questions are answered). */
+  web: LobbyWebConfig;
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
@@ -264,6 +281,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     miniLine: true,
     maxPlanningRounds: 5,
     splitPlanAbove: 8,
+    web: { enabled: false, port: 7347, openBrowser: true, questions: "both" },
   },
   classifier: {
     enabled: false,
@@ -326,7 +344,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; miniLine?: unknown; maxPlanningRounds?: unknown; splitPlanAbove?: unknown } | undefined;
+  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; miniLine?: unknown; maxPlanningRounds?: unknown; splitPlanAbove?: unknown; web?: 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)))]
@@ -344,9 +362,23 @@ function normalizeLobby(value: unknown): LobbyConfig {
     miniLine: flag(source?.miniLine, defaults.miniLine),
     maxPlanningRounds: roundLimit(source?.maxPlanningRounds, defaults.maxPlanningRounds),
     splitPlanAbove: roundLimit(source?.splitPlanAbove, defaults.splitPlanAbove),
+    web: normalizeLobbyWeb(source?.web, defaults.web),
   };
 }
 
+/** The loopback web UI's config: 0 or a real port, `both` or `terminal`; anything else keeps the default. */
+function normalizeLobbyWeb(value: unknown, fallback: LobbyWebConfig): LobbyWebConfig {
+  const source = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
+  const port = source.port === 0 ? 0 : webPort(source.port, fallback.port);
+  const questions = source.questions === "both" || source.questions === "terminal" ? source.questions : fallback.questions;
+  return { enabled: flag(source.enabled, fallback.enabled), port, openBrowser: flag(source.openBrowser, fallback.openBrowser), questions };
+}
+
+/** A TCP port (0 means any free port); anything else keeps the default. */
+function webPort(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535 ? value : fallback;
+}
+
 /** A whole number of rounds, 0 for unlimited; anything else keeps the default. */
 function roundLimit(value: unknown, fallback: number): number {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : fallback;

package/src/state/changes.ts

@@ -10,7 +10,7 @@
 import { appendFileSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
-import type { ChangeBaseline, Task } from "../schemas/task.ts";
+import type { Task } from "../schemas/task.ts";
 import { dataRoot } from "./project.ts";
 
 export type ChangeSource = "quickfix" | "worker";

package/src/state/persistence.ts

@@ -145,7 +145,7 @@ function taskEntries(root: string, configDir: string): { entry: string; dir: str
 /** All tasks on disk, newest first. Unreadable task dirs are skipped. */
 export function listTasks(root: string, configDir: string): Task[] {
   const tasks: Task[] = [];
-  for (const { entry, dir } of taskEntries(root, configDir)) {
+  for (const { dir } of taskEntries(root, configDir)) {
     const task = readTaskAt(dir);
     if (task) tasks.push(task);
   }

package/src/state/presence.ts

@@ -19,6 +19,8 @@ export interface Presence {
   sessionFile?: string;
   /** The task it drives, if any. */
   taskId?: string;
+  /** The loopback web UI's port, while this session's server runs. */
+  webPort?: number;
   /** `tui` for a terminal, `rpc` for a session another window started in the background. */
   mode: string;
   updatedAt: string;

package/src/webui/api/excalidraw.ts

@@ -0,0 +1,105 @@
+/**
+ * The Excalidraw tab over HTTP: the shared sessions, adding one from a link
+ * or making a new room, assigning agents, and checking a room. Sessions are
+ * listed with masked links (`room <id>`); only `reveal` returns the full
+ * link, so the page holds a room key only while it shows one. Actions answer
+ * with the same notice text the terminal shows.
+ */
+import { EXCALIDRAW_AGENTS, type ExcalidrawAgent, type ExcalidrawSession } from "../../excalidraw/sessions.ts";
+import { maskedLink, parseRoomLink } from "../../excalidraw/room.ts";
+import type { ExcalidrawAgentName, ExcalidrawSessionInfo } from "../protocol.ts";
+import type { ApiContext } from "./index.ts";
+import { fail } from "./index.ts";
+
+/** A session with its key hidden, for every call but `reveal`. */
+export function masked(session: ExcalidrawSession): ExcalidrawSessionInfo {
+  const link = parseRoomLink(session.link);
+  return {
+    id: session.id,
+    name: session.name,
+    masked: link ? maskedLink(link) : "invalid link",
+    agents: [...session.agents],
+    contribute: session.contribute,
+    addedAt: session.addedAt,
+  };
+}
+
+function pick(ctx: ApiContext, id: string): ExcalidrawSession {
+  const session = ctx.service.excalidraw.list().find((entry) => entry.id === id);
+  if (!session) fail(404, "not_found", "no such session");
+  return session!;
+}
+
+/** Every session, oldest first, with masked links. */
+export function excalidrawList(ctx: ApiContext): { sessions: ExcalidrawSessionInfo[] } {
+  return { sessions: ctx.service.excalidraw.list().map(masked) };
+}
+
+/** Add a session from a link the user pasted, named `name` (or after its room). */
+export function excalidrawAdd(body: { link: string; name?: string }, ctx: ApiContext): { notice: string; id?: string } {
+  const added = ctx.service.excalidraw.add(body.link, body.name);
+  if (!added.session) {
+    if (added.notice.startsWith("that is not")) fail(400, "bad_request", added.notice);
+    fail(409, "conflict", added.notice);
+  }
+  return { notice: added.notice, id: added.session!.id };
+}
+
+/** Make a new room, for the user to open in Excalidraw. */
+export function excalidrawCreate(body: { name?: string }, ctx: ApiContext): { notice: string; id?: string } {
+  const made = ctx.service.excalidraw.create(body.name);
+  if (!made.session) fail(409, "conflict", made.notice);
+  return { notice: made.notice, id: made.session!.id };
+}
+
+/** Remove a session (agents lose it at once; the room itself is untouched). */
+export function excalidrawRemove(body: { id: string }, ctx: ApiContext): { notice: string } {
+  const notice = ctx.service.excalidraw.remove(body.id);
+  if (notice === "no such session") fail(404, "not_found", notice);
+  return { notice };
+}
+
+/** Rename a session. */
+export function excalidrawRename(body: { id: string; name: string }, ctx: ApiContext): { notice: string } {
+  const notice = ctx.service.excalidraw.rename(body.id, body.name);
+  if (notice === "no such session") fail(404, "not_found", notice);
+  if (notice === "a session needs a name") fail(400, "bad_request", notice);
+  return { notice };
+}
+
+/** Assign a session to an agent, or take it back. */
+export function excalidrawToggleAgent(body: { id: string; agent: ExcalidrawAgentName }, ctx: ApiContext): { notice: string } {
+  if (!isAgent(body.agent)) fail(400, "bad_request", `no agent ${body.agent}`);
+  const notice = ctx.service.excalidraw.toggleAgent(body.id, body.agent as ExcalidrawAgent);
+  if (notice === "no such session") fail(404, "not_found", notice);
+  return { notice };
+}
+
+function isAgent(value: string): value is ExcalidrawAgent {
+  return (EXCALIDRAW_AGENTS as readonly string[]).includes(value);
+}
+
+/** Assign a session to every agent, or (when they all have it) to none. */
+export function excalidrawToggleAll(body: { id: string }, ctx: ApiContext): { notice: string } {
+  const notice = ctx.service.excalidraw.toggleAll(body.id);
+  if (notice === "no such session") fail(404, "not_found", notice);
+  return { notice };
+}
+
+/** Let the agents draw in a session, or only look at it. */
+export function excalidrawToggleContribute(body: { id: string }, ctx: ApiContext): { notice: string } {
+  const notice = ctx.service.excalidraw.toggleContribute(body.id);
+  if (notice === "no such session") fail(404, "not_found", notice);
+  return { notice };
+}
+
+/** Check a session: join the room for a moment and report who is there. */
+export async function excalidrawCheck(body: { id: string }, ctx: ApiContext): Promise<{ ok: boolean; text: string }> {
+  const session = pick(ctx, body.id);
+  return ctx.service.checkExcalidraw(session);
+}
+
+/** The full room link — the only call that returns one. */
+export function excalidrawReveal(body: { id: string }, ctx: ApiContext): { link: string } {
+  return { link: pick(ctx, body.id).link };
+}

package/src/webui/api/gh-error.ts

@@ -0,0 +1,17 @@
+/**
+ * A failed `gh` read as an HTTP refusal. `gh` owns authentication and the
+ * repository, and its failures arrive as one readable line (`ghError`): a
+ * number it cannot find is 404, anything else (not installed, not signed in,
+ * no GitHub remote, a timeout) is a 500 carrying that line. No token or
+ * command line is ever in the message.
+ */
+import { fail } from "./index.ts";
+
+const UNKNOWN_NUMBER = /could not resolve|no (pull request|issue)s? found|not found/i;
+
+/** Refuse with `gh`'s own words (`what` names the read when it left none). */
+export function ghRefusal(message: string | undefined, what: string): never {
+  const text = message ?? `could not read ${what}`;
+  if (UNKNOWN_NUMBER.test(text)) fail(404, "not_found", text);
+  fail(500, "failed", text);
+}