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

package/src/pi/tools.ts

@@ -9,10 +9,9 @@ import { classifier, effortFor, hintsFor, knowledgeFor, triageFor } from "../cla
 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 { askChoice, askText, askUser, canAsk } from "../ask/web.ts";
 import type { AskQuestion } from "../ask/types.ts";
-import { unescapeBreaks } from "../lobby/markdown.ts";
+import { unescapeBreaks } from "../lobby/blocks.ts";
 import { isQuiet } from "./quiet.ts";
 import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
@@ -126,11 +125,11 @@ export function workflowDeps(
     triage: (request, triageSignal) => triageFor({ cwd: ctx.cwd, root, configDir }, request, triageSignal),
     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(() => 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),
+    // The questions go to the web page, where a free-text answer may run to several lines.
+    ask: async (question) => (canAsk() ? whileAsking(() => askText(question)) : undefined),
+    choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options)) : undefined),
     // An agent's own questions (the designer's), relayed as the questionnaire.
-    ...(hasUI ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => promptHub.run("questionnaire", from, { questions }, () => askUser(questions, ctx, askSignal, from), askSignal ? { signal: askSignal } : undefined)) } : {}),
+    ...(canAsk() ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),
     notify: (message, level = "info") => {
       if (hasUI) ctx.ui.notify(message, level);
     },

package/src/pi/ui.ts

@@ -80,17 +80,8 @@ export function isMinimized(): boolean {
   return minimized;
 }
 
-/** Told when minimize changes, so the lobby can step aside too. */
-let minimizeListener: ((value: boolean) => void) | undefined;
-
-export function onMinimizeChange(listener: ((value: boolean) => void) | undefined): void {
-  minimizeListener = listener;
-}
-
 export function setMinimized(value: boolean): void {
-  if (minimized === value) return;
   minimized = value;
-  minimizeListener?.(value);
 }
 
 /** Flip minimize/restore and refresh the footer; the session is unchanged. */

package/src/schemas/configuration.ts

@@ -120,39 +120,24 @@ 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`. */
+/** The loopback web UI: it starts with every interactive session. */
 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`. */
+  /** Open the link in the browser when the session starts. */
   openBrowser: boolean;
-  questions: LobbyWebQuestions;
 }
 
-/** The full-screen lobby. */
+/** The web 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. */
+  /** Which panes the Lobby tab shows. */
   panels: Record<LobbyPanel, boolean>;
-  /** Key overrides by action name, e.g. `{ "toggleThinking": "alt+t" }`. */
+  /** Key overrides by action name, e.g. `{ "search": "alt+f" }`. */
   keys: Record<string, string>;
-  /** A one-line status (task steps, planning round, quick fix, or idle) under the editor while the lobby is hidden. */
-  miniLine: boolean;
-  /** Clicks and the wheel work in the lobby (click a draft line to comment on it); shift+drag still selects text. */
-  mouse: boolean;
   /**
    * Planning rounds before the oracle finalizes the plan on its own: the last
    * round skips the seats and asks nothing; later replies only revise. 0 = unlimited.
@@ -271,17 +256,13 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     scratchpadMaxChars: 2000,
   },
   lobby: {
-    autoOpen: true,
     planningPanel: [...PANEL_MEMBERS],
-    autoAsk: true,
     issues: false,
     panels: { conversation: true, activity: true, thinking: true },
     keys: {},
-    mouse: true,
-    miniLine: true,
     maxPlanningRounds: 5,
     splitPlanAbove: 8,
-    web: { enabled: false, port: 7347, openBrowser: true, questions: "both" },
+    web: { port: 7347, openBrowser: true },
   },
   classifier: {
     enabled: false,
@@ -344,7 +325,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; web?: unknown } | undefined;
+  const source = value as { planningPanel?: unknown; issues?: unknown; panels?: unknown; keys?: 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)))]
@@ -352,26 +333,21 @@ function normalizeLobby(value: unknown): LobbyConfig {
   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: 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),
-    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. */
+/** The loopback web UI's config: 0 or a real port; 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 };
+  return { port, openBrowser: flag(source.openBrowser, fallback.openBrowser) };
 }
 
 /** A TCP port (0 means any free port); anything else keeps the default. */

package/src/state/attachments.ts

@@ -0,0 +1,82 @@
+/**
+ * Files attached in the lobby's composer live in a temp folder outside the
+ * repository. Each one sent while a task was in play is remembered against
+ * that task, and removed when the task completes, is abandoned, archived or
+ * deleted. Files never sent, or sent with no task, go after a few days.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** The folder the page's preview route serves attachments from. */
+export function attachmentDir(): string {
+  return join(tmpdir(), "bot-lobby-previews", "attachments");
+}
+
+function indexPath(): string {
+  return join(tmpdir(), "bot-lobby-previews", "attachments.json");
+}
+
+function readIndex(): Record<string, string> {
+  try {
+    const parsed = JSON.parse(readFileSync(indexPath(), "utf8")) as Record<string, unknown>;
+    return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, string] => typeof entry[1] === "string"));
+  } catch {
+    return {};
+  }
+}
+
+function writeIndex(index: Record<string, string>): void {
+  try {
+    mkdirSync(join(tmpdir(), "bot-lobby-previews"), { recursive: true });
+    writeFileSync(indexPath(), JSON.stringify(index), { mode: 0o600 });
+  } catch {
+    // The files then fall to the age sweep.
+  }
+}
+
+/** Remember that `ids` belong to `taskId`. */
+export function claimAttachments(ids: readonly string[], taskId: string): void {
+  if (ids.length === 0) return;
+  const index = readIndex();
+  for (const id of ids) index[id] = taskId;
+  writeIndex(index);
+}
+
+/** Delete every file that was sent while `taskId` was in play. */
+export function releaseAttachments(taskId: string): number {
+  const index = readIndex();
+  let removed = 0;
+  for (const [id, owner] of Object.entries(index)) {
+    if (owner !== taskId) continue;
+    try {
+      rmSync(join(attachmentDir(), id), { force: true });
+      removed += 1;
+    } catch {
+      // A file already gone is the goal.
+    }
+    delete index[id];
+  }
+  if (removed > 0 || Object.keys(index).length !== Object.keys(readIndex()).length) writeIndex(index);
+  return removed;
+}
+
+/** Delete files older than `maxAgeMs` that no task claimed. */
+export function sweepAttachments(maxAgeMs: number, now = Date.now()): number {
+  const dir = attachmentDir();
+  if (!existsSync(dir)) return 0;
+  const claimed = new Set(Object.keys(readIndex()));
+  let removed = 0;
+  for (const name of readdirSync(dir)) {
+    if (claimed.has(name)) continue;
+    try {
+      if (now - statSync(join(dir, name)).mtimeMs > maxAgeMs) {
+        rmSync(join(dir, name), { force: true });
+        removed += 1;
+      }
+    } catch {
+      // Skip what cannot be read.
+    }
+  }
+  return removed;
+}

package/src/webui/api/index.ts

@@ -9,7 +9,7 @@ import type { ServerResponse } from "node:http";
 import { Type, type TObject } from "typebox";
 import { Compile } from "typebox/compile";
 import { statusFor, type ApiName, type ErrorCode } from "../protocol.ts";
-import type { LobbyService } from "../../lobby/service.ts";
+import type { LobbyService } from "../../lobby/host.ts";
 import { statusGet } from "./status.ts";
 import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
@@ -78,6 +78,8 @@ const Empty = Type.Object({}, { additionalProperties: false });
 const TaskId = Type.String({ minLength: 1, maxLength: 200 });
 const GhNumber = Type.Integer({ minimum: 1, maximum: 1_000_000_000 });
 const NoticeText = Type.String({ maxLength: 20_000 });
+/** Ids of files uploaded through `files.upload`; the message names them by path. */
+const Attachments = Type.Optional(Type.Array(Type.String({ minLength: 1, maxLength: 200 }), { maxItems: 8 }));
 const CommentText = Type.String({ maxLength: 10_000 });
 const DialogAnswer = Type.Union([
   Type.Object({ value: Type.String() }, { additionalProperties: false }),
@@ -112,8 +114,8 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => lobbyHistory(body as { before?: number }, ctx),
   };
   routes["lobby.send"] = {
-    schema: Type.Object({ text: Type.String({ maxLength: 20_000 }) }, { additionalProperties: false }),
-    run: (body, ctx) => lobbySend(body as { text: string }, ctx),
+    schema: Type.Object({ text: Type.String({ maxLength: 20_000 }), attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => lobbySend(body as { text: string; attachments?: string[] }, ctx),
   };
   routes["lobby.abort"] = { schema: Empty, run: (_body, ctx) => lobbyAbort(ctx) };
   routes["tasks.list"] = { schema: Empty, run: (_body, ctx) => tasksList(ctx) };
@@ -127,8 +129,8 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => tasksComments(body as { taskId: string }, ctx),
   };
   routes["tasks.comment"] = {
-    schema: Type.Object({ taskId: TaskId, text: CommentText }, { additionalProperties: false }),
-    run: (body, ctx) => tasksComment(body as { taskId: string; text: string }, ctx),
+    schema: Type.Object({ taskId: TaskId, text: CommentText, attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => tasksComment(body as { taskId: string; text: string; attachments?: string[] }, ctx),
   };
   routes["tasks.archive"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
@@ -147,8 +149,8 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => tasksAuto(body as { taskId: string; on: boolean }, ctx),
   };
   routes["tasks.message"] = {
-    schema: Type.Object({ taskId: TaskId, text: NoticeText }, { additionalProperties: false }),
-    run: (body, ctx) => tasksMessage(body as { taskId: string; text: string }, ctx),
+    schema: Type.Object({ taskId: TaskId, text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => tasksMessage(body as { taskId: string; text: string; attachments?: string[] }, ctx),
   };
   routes["plans.get"] = {
     schema: Type.Object({ planId: TaskId }, { additionalProperties: false }),
@@ -168,16 +170,16 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => sessionsChat(body as { key?: string; sessionId?: string; before?: number }, ctx),
   };
   routes["sessions.start"] = {
-    schema: Type.Object({ request: Type.Optional(NoticeText), planId: Type.Optional(TaskId), auto: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
-    run: (body, ctx) => sessionsStart(body as { request?: string; planId?: string; auto?: boolean }, ctx),
+    schema: Type.Object({ request: Type.Optional(NoticeText), planId: Type.Optional(TaskId), auto: Type.Optional(Type.Boolean()), attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => sessionsStart(body as { request?: string; planId?: string; auto?: boolean; attachments?: string[] }, ctx),
   };
   routes["sessions.stop"] = {
     schema: Type.Object({ key: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => sessionsStop(body as { key: string }, ctx),
   };
   routes["sessions.message"] = {
-    schema: Type.Object({ key: Type.Optional(TaskId), sessionId: Type.Optional(TaskId), text: NoticeText }, { additionalProperties: false }),
-    run: (body, ctx) => sessionsMessage(body as { key?: string; sessionId?: string; text: string }, ctx),
+    schema: Type.Object({ key: Type.Optional(TaskId), sessionId: Type.Optional(TaskId), text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => sessionsMessage(body as { key?: string; sessionId?: string; text: string; attachments?: string[] }, ctx),
   };
   routes["sessions.switch"] = {
     schema: Type.Object({ key: Type.Optional(TaskId), sessionId: Type.Optional(TaskId), claimTaskId: Type.Optional(TaskId) }, { additionalProperties: false }),
@@ -202,8 +204,8 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => plannerNew(body as { seed?: { issue: { number: number; title: string; url?: string }; body: string }; seats?: ("backend" | "designer" | "qa" | "researcher")[] }, ctx),
   };
   routes["planner.send"] = {
-    schema: Type.Object({ text: NoticeText }, { additionalProperties: false }),
-    run: (body, ctx) => plannerSend(body as { text: string }, ctx),
+    schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => plannerSend(body as { text: string; attachments?: string[] }, ctx),
   };
   routes["planner.toggleSeat"] = {
     schema: Type.Object({ member: Member }, { additionalProperties: false }),
@@ -218,8 +220,8 @@ function buildRoutes(): Record<string, Route> {
   routes["planner.save"] = { schema: Empty, run: (_body, ctx) => plannerSave(ctx) };
   routes["quickfix.list"] = { schema: Empty, run: (_body, ctx) => quickfixList(ctx) };
   routes["quickfix.submit"] = {
-    schema: Type.Object({ text: NoticeText }, { additionalProperties: false }),
-    run: (body, ctx) => quickfixSubmit(body as { text: string }, ctx),
+    schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
+    run: (body, ctx) => quickfixSubmit(body as { text: string; attachments?: string[] }, ctx),
   };
   routes["quickfix.cancel"] = {
     schema: Type.Object({ id: TaskId }, { additionalProperties: false }),

package/src/webui/api/lobby.ts

@@ -7,6 +7,7 @@
 import { MAX_ACTIVITY, MAX_CHAT, MAX_THOUGHTS } from "../../lobby/feed.ts";
 import type { Task } from "../../schemas/task.ts";
 import type { ApiContext } from "./index.ts";
+import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 import { taskSteps } from "./plan-facts.ts";
 import type { LobbySnapshot, SnapshotTask } from "../protocol.ts";
@@ -74,9 +75,9 @@ export function lobbyHistory(body: { before?: number }, ctx: ApiContext): { entr
 }
 
 /** Text for the oracle; a notice when it was not simply sent. */
-export function lobbySend(body: { text: string }, ctx: ApiContext): { notice?: string } {
-  if (!body.text.trim()) return { notice: "type something first" };
-  const notice = ctx.service.toOracle(body.text);
+export function lobbySend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
+  if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
+  const notice = ctx.service.toOracle(withAttachments(body.text, body.attachments, ctx.service.zen().task?.id));
   return notice ? { notice } : {};
 }
 

package/src/webui/api/planner.ts

@@ -8,6 +8,7 @@ import { MEMBER_LABELS } from "../../lobby/planner.ts";
 import type { PanelMember } from "../../schemas/configuration.ts";
 import type { PlannerSnapshot } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
+import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 
 /** The planning session as the page reads it; absent means no session yet. */
@@ -47,11 +48,12 @@ export function plannerNew(body: { seed?: { issue: { number: number; title: stri
 }
 
 /** Send a message to the panel; the round runs in the background. */
-export function plannerSend(body: { text: string }, ctx: ApiContext): { notice: string } {
-  if (!body.text.trim()) fail(400, "bad_request", "describe the task to plan");
+export function plannerSend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice: string } {
+  if (!body.text.trim() && !body.attachments?.length) fail(400, "bad_request", "describe the task to plan");
+  const text = withAttachments(body.text, body.attachments);
   const session = ctx.service.planner() ?? ctx.service.newPlanner(undefined, [...ctx.service.defaultPanel()]);
-  if (session!.busy) fail(409, "conflict", "the panel is still thinking — x stops it");
-  session!.send(body.text).catch(() => {});
+  if (session!.busy) fail(409, "conflict", "the panel is still thinking — wait for the round to finish");
+  session!.send(text).catch(() => {});
   return { notice: "sent — the panel is on the next round" };
 }
 

package/src/webui/api/quickfix.ts

@@ -5,6 +5,7 @@
  * terminal shows.
  */
 import type { ApiContext } from "./index.ts";
+import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 import type { QuickFixJob } from "../../lobby/quickfix.ts";
 
@@ -14,9 +15,9 @@ export function quickfixList(ctx: ApiContext): { jobs: QuickFixJob[] } {
 }
 
 /** Queue a quick fix; it starts at once when nothing else is running. */
-export function quickfixSubmit(body: { text: string }, ctx: ApiContext): { notice: string; id: string } {
-  if (!body.text.trim()) fail(400, "bad_request", "describe a quick change first");
-  const job = ctx.service.quickfix.submit(body.text);
+export function quickfixSubmit(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice: string; id: string } {
+  if (!body.text.trim() && !body.attachments?.length) fail(400, "bad_request", "describe a quick change first");
+  const job = ctx.service.quickfix.submit(withAttachments(body.text, body.attachments));
   return { notice: ctx.service.quickfix.running?.id === job.id ? `${job.id} started` : `${job.id} queued behind the running quick fix`, id: job.id };
 }
 

package/src/webui/api/sessions.ts

@@ -7,6 +7,7 @@
  */
 import type { BackgroundSession, DialogAnswer } from "../../lobby/sessions.ts";
 import type { ApiContext } from "./index.ts";
+import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 import type { BackgroundSessionInfo } from "../protocol.ts";
 
@@ -50,7 +51,7 @@ function pageChat(all: unknown[], older: boolean, before?: number): { entries: u
 }
 
 /** Start a task in a new background session, from a request or a saved plan. */
-export function sessionsStart(body: { request?: string; planId?: string; auto?: boolean }, ctx: ApiContext): { notice: string; key?: string } {
+export function sessionsStart(body: { request?: string; planId?: string; auto?: boolean; attachments?: string[] }, ctx: ApiContext): { notice: string; key?: string } {
   if (body.request?.trim() && body.planId) fail(400, "bad_request", "start from a request or a plan, not both");
   if (body.planId) {
     const plan = ctx.service.plans().find((entry) => entry.id === body.planId);
@@ -59,8 +60,8 @@ export function sessionsStart(body: { request?: string; planId?: string; auto?:
     if (typeof session === "string") return { notice: session };
     return { notice: `started ${session.name} in a new session`, key: session.key };
   }
-  if (!body.request?.trim()) fail(400, "bad_request", "describe the task first");
-  const session = ctx.service.startSession({ request: body.request!.trim(), ...(body.auto ? { auto: true } : {}) });
+  if (!body.request?.trim() && !body.attachments?.length) fail(400, "bad_request", "describe the task first");
+  const session = ctx.service.startSession({ request: withAttachments((body.request ?? "").trim(), body.attachments), ...(body.auto ? { auto: true } : {}) });
   if (typeof session === "string") return { notice: session };
   return { notice: `started ${session.name} in a new session`, key: session.key };
 }
@@ -74,16 +75,17 @@ export function sessionsStop(body: { key: string }, ctx: ApiContext): { notice:
 }
 
 /** Message a session: background ones directly, other terminals through their inbox. */
-export function sessionsMessage(body: { key?: string; sessionId?: string; text: string }, ctx: ApiContext): { notice?: string } {
+export function sessionsMessage(body: { key?: string; sessionId?: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
   if (!body.key && !body.sessionId) fail(400, "bad_request", "a session key or id is required");
-  if (!body.text.trim()) return { notice: "type something first" };
+  if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
+  const text = withAttachments(body.text, body.attachments);
   const background = backgroundOf(ctx, body.key, body.sessionId);
   if (background) {
     if (!background.alive) fail(409, "conflict", `${background.name} has ended`);
-    background.send(body.text);
+    background.send(text);
     return {};
   }
-  return { notice: ctx.service.sendToSession(body.sessionId!, body.text) };
+  return { notice: ctx.service.sendToSession(body.sessionId!, text) };
 }
 
 /** Run a session in this window (stopping its background process first). */

package/src/webui/api/settings.ts

@@ -1,14 +1,15 @@
 /**
  * `settings.get` / `settings.set`: the effective bot-lobby config (never a
  * secret) and the models Pi offers. A set merges the patch over the current
- * config, normalises it through the same `resolveConfig` the terminal uses and
- * saves it the way the settings menu does, so the terminal sees the change.
- * The one terminal wording reused here is the port's; everything else the
+ * config, normalises it through `resolveConfig` and saves it; everything the
  * normaliser clamps or drops, so no unknown field is ever written.
  */
 import { resolveConfig, type BotLobbyConfig } from "../../schemas/configuration.ts";
 import { loadConfig, saveConfig } from "../../state/project.ts";
 import { lobbyTopics } from "../../lobby/topics.ts";
+import { prefillModels } from "../../pi/model-settings.ts";
+import { kindLabel } from "../../pi/model-support.ts";
+import { pushNotice } from "../notices.ts";
 import type { SettingsInfo } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
@@ -49,7 +50,7 @@ function writeConfig(ctx: ApiContext, config: BotLobbyConfig): void {
   else saveConfig(config);
 }
 
-/** Reject a port that is not 0 or 1-65535, with the terminal's wording. */
+/** Reject a port that is not 0 or 1-65535, . */
 function checkPort(patch: Record<string, unknown>): void {
   const lobby = isPlain(patch.lobby) ? patch.lobby : undefined;
   const web = lobby && isPlain(lobby.web) ? lobby.web : undefined;
@@ -65,7 +66,7 @@ function agentEntries(patch: Record<string, unknown>): unknown[] {
   return [patch.master, ...agents, patch.researcher, patch.quickFix, patch.planner, patch.scout];
 }
 
-/** Reject a time limit that is not a positive number, with the terminal's wording. */
+/** Reject a time limit that is not a positive number, . */
 function checkTimeouts(patch: Record<string, unknown>): void {
   for (const entry of agentEntries(patch)) {
     const timeout = isPlain(entry) ? entry.timeoutMs : undefined;
@@ -76,12 +77,23 @@ function checkTimeouts(patch: Record<string, unknown>): void {
   }
 }
 
-/** The page's first settings call. */
+/**
+ * The page's first settings call. Subagents never inherit a model silently:
+ * any whose model is still unset is pinned to the session's model and saved,
+ * so the page always shows what each agent runs on.
+ */
 export function settingsGet(ctx: ApiContext): SettingsInfo {
-  return { config: stripSecrets(readConfig(ctx)), models: ctx.service.models?.() ?? [] };
+  let config = readConfig(ctx);
+  const prefilled = prefillModels(config, ctx.service.sessionModel?.());
+  if (prefilled.filled.length > 0) {
+    writeConfig(ctx, prefilled.config);
+    config = prefilled.config;
+    pushNotice(`${prefilled.filled.map(kindLabel).join(", ")} now run on the session model; change them here any time.`);
+  }
+  return { config: stripSecrets(config), models: ctx.service.models?.() ?? [] };
 }
 
-/** Merge, normalise and save the patch; the terminal rerenders and rereads the config. */
+/** Merge, normalise and save the patch; the lobby rereads the config. */
 export function settingsSet(body: { patch: Record<string, unknown> }, ctx: ApiContext): { config: BotLobbyConfig } {
   checkPort(body.patch);
   checkTimeouts(body.patch);

package/src/webui/api/status.ts

@@ -1,11 +1,10 @@
 /**
  * `status.get`: everything the page shell needs before it reads a tab —
  * workspace, session, tabs, shortcuts and open windows. Tab ids and labels
- * come from the shared strings, shortcuts from the shared key map (with the
- * web-only tab cycling defaults), so the page matches the terminal exactly.
+ * come from the shared strings, shortcuts from the key map.
  */
 import { loadConfig } from "../../state/project.ts";
-import { LOBBY_ACTIONS, keyLabel, webKeyMap } from "../../lobby/keys.ts";
+import { LOBBY_ACTIONS, keyLabel, keyMap } from "../../lobby/keys.ts";
 import { TAB_LABELS, visibleTabs } from "../../lobby/prompts.ts";
 import type { ApiContext } from "./index.ts";
 import type { KeyInfo, StatusInfo, TabInfo } from "../protocol.ts";
@@ -15,7 +14,7 @@ function tabs(issuesEnabled: boolean): TabInfo[] {
 }
 
 function keys(overrides: Readonly<Record<string, string>>): KeyInfo[] {
-  const map = webKeyMap(overrides);
+  const map = keyMap(overrides);
   return (Object.keys(LOBBY_ACTIONS) as Array<keyof typeof LOBBY_ACTIONS>).map((action) => ({
     action,
     key: map[action],
@@ -24,16 +23,6 @@ function keys(overrides: Readonly<Record<string, string>>): KeyInfo[] {
   }));
 }
 
-/** Whether pi itself is asking in the terminal (a later surface reports it; false until one does). */
-function terminalDialog(ctx: ApiContext): boolean {
-  const extra = ctx.service as unknown as { terminalDialog?: () => boolean };
-  try {
-    return extra.terminalDialog?.() ?? false;
-  } catch {
-    return false;
-  }
-}
-
 /** The page shell's first call. */
 export function statusGet(ctx: ApiContext): StatusInfo {
   const service = ctx.service;
@@ -45,9 +34,9 @@ export function statusGet(ctx: ApiContext): StatusInfo {
     sessionId: service.sessionId() ?? undefined,
     sessionName: service.sessionName() ?? undefined,
     busy: service.masterBusy(),
-    terminalDialog: terminalDialog(ctx),
     port: ctx.port,
     issuesEnabled,
+    panels: loadConfig().lobby.panels,
     tabs: tabs(issuesEnabled),
     keys: keys(loadConfig().lobby.keys),
     windows: [],

package/src/webui/api/tasks.ts

@@ -1,23 +1,19 @@
 /**
  * The Tasks tab over HTTP: rows, archived tasks, plan comments, and the row
- * actions (comment, archive, restore, delete, auto mode, message). Actions
- * answer with the same notice text the terminal shows.
- *
- * The row shape mirrors `taskRows` in `src/lobby/tabs/tasks.ts`, whose pure
- * data part is rebuilt here instead of imported: that module draws through
- * `layout.ts` and would load the TUI (`@earendil-works/pi-tui`) into the
- * server. The one type import above is erased at compile time.
+ * actions (comment, archive, restore, delete, auto mode, message). The row
+ * shape is `TaskRow` in `src/lobby/task-rows.ts`.
  */
 import { TERMINAL_STATES, taskRequest, type Task } from "../../schemas/task.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
-import type { TaskRow } from "../../lobby/tabs/tasks.ts";
+import type { TaskRow } from "../../lobby/task-rows.ts";
 import type { TaskDetail } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
+import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 import { taskSteps } from "./plan-facts.ts";
-import type { TaskSection } from "../../lobby/tabs/tasks.ts";
+import type { TaskSection } from "../../lobby/task-rows.ts";
 
 interface RowContext {
   names: ReadonlyMap<string, string>;
@@ -140,9 +136,9 @@ export function tasksComments(body: { taskId: string }, ctx: ApiContext): { comm
 }
 
 /** Comment on a task's plan; blank text is a no-op notice like the lobby's. */
-export function tasksComment(body: { taskId: string; text: string }, ctx: ApiContext): { notice?: string } {
-  if (!body.text.trim()) return { notice: "type something first" };
-  return { notice: ctx.service.comment(body.taskId, body.text) };
+export function tasksComment(body: { taskId: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
+  if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
+  return { notice: ctx.service.comment(body.taskId, withAttachments(body.text, body.attachments, body.taskId)) };
 }
 
 /** Archive, restore or delete a task; each answers the terminal's notice. */
@@ -171,9 +167,9 @@ export function tasksAuto(body: { taskId: string; on: boolean }, ctx: ApiContext
 }
 
 /** Leave a message for a task's oracle; blank text is a no-op notice. */
-export function tasksMessage(body: { taskId: string; text: string }, ctx: ApiContext): { notice: string } {
-  if (!body.text.trim()) return { notice: "type something first" };
-  return { notice: ctx.service.sendToTask(body.taskId, body.text) };
+export function tasksMessage(body: { taskId: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice: string } {
+  if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
+  return { notice: ctx.service.sendToTask(body.taskId, withAttachments(body.text, body.attachments, body.taskId)) };
 }
 
 /** How many recent runs the detail lists (the terminal's count). */