diff --git a/app/src/App.tsx b/app/src/App.tsx
index dba635fe..7a6a0fd1 100644
--- a/app/src/App.tsx
+++ b/app/src/App.tsx
@@ -4,6 +4,7 @@ import { type Connect, createLink } from "./features/onboarding/link";
 import { Onboarding } from "./features/onboarding/Onboarding";
 import type { Host } from "./lib/host";
 import { useCloseBehavior } from "./shell/closing";
+import { useMotionRoot } from "./shell/motionRoot";
 import { TitleBar } from "./shell/TitleBar";
 import { useThemeRoot } from "./shell/theme";
 import { Workspace } from "./shell/Workspace";
@@ -13,6 +14,7 @@ import { Toaster } from "./ui/toast";
 
 export function App({ host, connect }: { host: Host; connect: Connect }) {
   useThemeRoot();
+  useMotionRoot();
   useZoomRoot(host);
   useCloseBehavior(host);
   const [link] = useState(() => createLink(host, connect));
diff --git a/app/src/features/account/AppearanceSettings.tsx b/app/src/features/account/AppearanceSettings.tsx
new file mode 100644
index 00000000..6c68bccf
--- /dev/null
+++ b/app/src/features/account/AppearanceSettings.tsx
@@ -0,0 +1,42 @@
+// Settings, "Appearance": theme, size and motion (spec 15.3).
+
+import { useT } from "../../i18n";
+import { prefs, usePref } from "../../shell/prefs";
+import { setTheme, type ThemeChoice, useTheme } from "../../shell/theme";
+import { DEFAULT_ZOOM, setZoom, useZoom, ZOOM_LEVELS, type ZoomLevel } from "../../shell/zoom";
+import { Choices } from "../../ui/Choices";
+import { Field, Section, Toggle } from "./settingsParts";
+
+export function AppearanceSettings() {
+  const t = useT();
+  const s = t.account.settings;
+  const { choice: theme } = useTheme();
+  const zoom = useZoom();
+  const lessMotion = usePref(prefs.lessMotion);
+  const themes: { value: ThemeChoice; label: string }[] = [
+    { value: "system", label: s.themes.system },
+    { value: "light", label: s.themes.light },
+    { value: "dark", label: s.themes.dark },
+  ];
+  const sizes = ZOOM_LEVELS.map((level) => ({
+    value: level,
+    label: t.shell.zoom.level(Math.round(level * 100), level === DEFAULT_ZOOM),
+  }));
+
+  return (
+    <Section title={s.appearance}>
+      <Field label={s.theme}>
+        <Choices label={s.theme} value={theme} options={themes} onChange={setTheme} />
+      </Field>
+      <Field label={s.size} hint={s.sizeHint}>
+        <Choices<ZoomLevel> label={s.size} value={zoom} options={sizes} onChange={setZoom} />
+      </Field>
+      <Toggle
+        label={s.lessMotion}
+        hint={s.lessMotionHint}
+        checked={lessMotion}
+        onChange={prefs.lessMotion.set}
+      />
+    </Section>
+  );
+}
diff --git a/app/src/features/account/BackgroundSettings.tsx b/app/src/features/account/BackgroundSettings.tsx
deleted file mode 100644
index a422e603..00000000
--- a/app/src/features/account/BackgroundSettings.tsx
+++ /dev/null
@@ -1,40 +0,0 @@
-// Settings, "In the background" (spec 15.1): whether the bots keep working
-// after the window closes, whether Botloft starts with Windows, and
-// whether the computer stays awake while they work.
-
-import { useT } from "../../i18n";
-import { setWhenClosed, useWhenClosed } from "../../shell/closing";
-import { Section, Toggle } from "./settingsParts";
-import { useDaemonSettings } from "./useDaemonSettings";
-
-export function BackgroundSettings() {
-  const s = useT().account.settings;
-  const whenClosed = useWhenClosed();
-  const { settings, change } = useDaemonSettings();
-  const startWithWindows = settings?.startWithWindows ?? true;
-
-  return (
-    <Section title={s.background}>
-      <Toggle
-        label={s.keepWorking}
-        hint={whenClosed === "keep" ? s.keepWorkingOn : s.keepWorkingOff}
-        checked={whenClosed === "keep"}
-        onChange={(on) => setWhenClosed(on ? "keep" : "stop")}
-      />
-      <Toggle
-        label={s.startWithWindows}
-        hint={startWithWindows ? s.startWithWindowsOn : s.startWithWindowsOff}
-        checked={startWithWindows}
-        disabled={!settings}
-        onChange={(on) => change({ startWithWindows: on })}
-      />
-      <Toggle
-        label={s.keepAwake}
-        hint={s.keepAwakeHint}
-        checked={settings?.keepAwake ?? true}
-        disabled={!settings}
-        onChange={(on) => change({ keepAwake: on })}
-      />
-    </Section>
-  );
-}
diff --git a/app/src/features/account/ChatSettings.tsx b/app/src/features/account/ChatSettings.tsx
new file mode 100644
index 00000000..5c5ec162
--- /dev/null
+++ b/app/src/features/account/ChatSettings.tsx
@@ -0,0 +1,28 @@
+// Settings, "Chat": how a message is sent, and whether the panel beside
+// the chat follows what the bot starts doing (spec 15.1).
+
+import { useT } from "../../i18n";
+import { prefs, usePref } from "../../shell/prefs";
+import { Section, Toggle } from "./settingsParts";
+
+export function ChatSettings() {
+  const s = useT().account.settings;
+  const enterSends = usePref(prefs.enterSends);
+  const followBot = usePref(prefs.followBot);
+  return (
+    <Section title={s.chat}>
+      <Toggle
+        label={s.enterSends}
+        hint={enterSends ? s.enterSendsOn : s.enterSendsOff}
+        checked={enterSends}
+        onChange={prefs.enterSends.set}
+      />
+      <Toggle
+        label={s.followBot}
+        hint={followBot ? s.followBotOn : s.followBotOff}
+        checked={followBot}
+        onChange={prefs.followBot.set}
+      />
+    </Section>
+  );
+}
diff --git a/app/src/features/account/GeneralSettings.tsx b/app/src/features/account/GeneralSettings.tsx
new file mode 100644
index 00000000..327afbff
--- /dev/null
+++ b/app/src/features/account/GeneralSettings.tsx
@@ -0,0 +1,59 @@
+// Settings, "General": the language, and what Botloft does in the
+// background (spec 15.1).
+
+import {
+  LOCALES,
+  type LocaleChoice,
+  setLocaleChoice,
+  systemLocale,
+  useLocale,
+  useT,
+} from "../../i18n";
+import { prefs, usePref } from "../../shell/prefs";
+import { Select } from "../../ui/Select";
+import { Section, Toggle } from "./settingsParts";
+import { useDaemonSettings } from "./useDaemonSettings";
+
+export function GeneralSettings() {
+  const t = useT();
+  const s = t.account.settings;
+  const whenClosed = usePref(prefs.whenClosed);
+  const { settings, change } = useDaemonSettings();
+  const startWithWindows = settings?.startWithWindows ?? true;
+  const { choice: locale } = useLocale();
+  const systemName = LOCALES.find((entry) => entry.id === systemLocale())?.name ?? "English";
+  const languages: { value: LocaleChoice; label: string }[] = [
+    { value: "system", label: t.shell.language.system(systemName) },
+    ...LOCALES.map((entry) => ({ value: entry.id as LocaleChoice, label: entry.name })),
+  ];
+
+  return (
+    <>
+      <Section title={s.language}>
+        <Select label={s.language} value={locale} options={languages} onChange={setLocaleChoice} />
+      </Section>
+      <Section title={s.background}>
+        <Toggle
+          label={s.keepWorking}
+          hint={whenClosed === "keep" ? s.keepWorkingOn : s.keepWorkingOff}
+          checked={whenClosed === "keep"}
+          onChange={(on) => prefs.whenClosed.set(on ? "keep" : "stop")}
+        />
+        <Toggle
+          label={s.startWithWindows}
+          hint={startWithWindows ? s.startWithWindowsOn : s.startWithWindowsOff}
+          checked={startWithWindows}
+          disabled={!settings}
+          onChange={(on) => change({ startWithWindows: on })}
+        />
+        <Toggle
+          label={s.keepAwake}
+          hint={s.keepAwakeHint}
+          checked={settings?.keepAwake ?? true}
+          disabled={!settings}
+          onChange={(on) => change({ keepAwake: on })}
+        />
+      </Section>
+    </>
+  );
+}
diff --git a/app/src/features/account/SettingsDialog.tsx b/app/src/features/account/SettingsDialog.tsx
index 58e5366b..2fb9b702 100644
--- a/app/src/features/account/SettingsDialog.tsx
+++ b/app/src/features/account/SettingsDialog.tsx
@@ -1,66 +1,71 @@
-// Settings (spec 15.1): whether Botloft works in the background, the
-// theme, size and language, which used to sit in the title bar, and the
-// versions for when something needs reporting.
+// Settings (spec 15.1), in parts listed on the left: general (what
+// Botloft does in the background, the language), the chat, the look, and
+// the versions for when something needs reporting.
 
-import {
-  LOCALES,
-  type LocaleChoice,
-  setLocaleChoice,
-  systemLocale,
-  useLocale,
-  useT,
-} from "../../i18n";
-import { setTheme, type ThemeChoice, useTheme } from "../../shell/theme";
-import { DEFAULT_ZOOM, setZoom, useZoom, ZOOM_LEVELS, type ZoomLevel } from "../../shell/zoom";
-import { Choices } from "../../ui/Choices";
+import { Info, type LucideIcon, MessageSquare, Palette, SlidersHorizontal } from "lucide-react";
+import { useId, useState } from "react";
+import { useT } from "../../i18n";
 import { Dialog } from "../../ui/Dialog";
 import { AboutSettings } from "./AboutSettings";
-import { BackgroundSettings } from "./BackgroundSettings";
-import { Field, Section } from "./settingsParts";
+import { AppearanceSettings } from "./AppearanceSettings";
+import { ChatSettings } from "./ChatSettings";
+import { GeneralSettings } from "./GeneralSettings";
 
-export function SettingsDialog({ onClose }: { onClose(): void }) {
-  const t = useT();
-  const s = t.account.settings;
-  const { choice: theme } = useTheme();
-  const zoom = useZoom();
-  const { choice: locale } = useLocale();
-  const systemName = LOCALES.find((entry) => entry.id === systemLocale())?.name ?? "English";
+type Page = "general" | "chat" | "appearance" | "about";
+
+const PAGES: { id: Page; icon: LucideIcon }[] = [
+  { id: "general", icon: SlidersHorizontal },
+  { id: "chat", icon: MessageSquare },
+  { id: "appearance", icon: Palette },
+  { id: "about", icon: Info },
+];
 
-  const themes: { value: ThemeChoice; label: string }[] = [
-    { value: "system", label: s.themes.system },
-    { value: "light", label: s.themes.light },
-    { value: "dark", label: s.themes.dark },
-  ];
-  const sizes = ZOOM_LEVELS.map((level) => ({
-    value: level,
-    label: t.shell.zoom.level(Math.round(level * 100), level === DEFAULT_ZOOM),
-  }));
-  const languages: { value: LocaleChoice; label: string }[] = [
-    { value: "system", label: t.shell.language.system(systemName) },
-    ...LOCALES.map((entry) => ({ value: entry.id as LocaleChoice, label: entry.name })),
-  ];
+export function SettingsDialog({ onClose }: { onClose(): void }) {
+  const s = useT().account.settings;
+  const [page, setPage] = useState<Page>("general");
+  const id = useId();
 
   return (
     <Dialog title={s.title} onClose={onClose} width="lg">
-      <div className="flex flex-col gap-6">
-        <BackgroundSettings />
-        <Section title={s.appearance}>
-          <Field label={s.theme}>
-            <Choices label={s.theme} value={theme} options={themes} onChange={setTheme} />
-          </Field>
-          <Field label={s.size} hint={s.sizeHint}>
-            <Choices<ZoomLevel> label={s.size} value={zoom} options={sizes} onChange={setZoom} />
-          </Field>
-        </Section>
-        <Section title={s.language}>
-          <Choices
-            label={s.language}
-            value={locale}
-            options={languages}
-            onChange={setLocaleChoice}
-          />
-        </Section>
-        <AboutSettings />
+      <div className="flex min-h-[27rem] gap-5">
+        <div
+          role="tablist"
+          aria-label={s.pages}
+          aria-orientation="vertical"
+          className="flex w-40 shrink-0 flex-col gap-0.5"
+        >
+          {PAGES.map(({ id: each, icon: Icon }) => {
+            const selected = each === page;
+            return (
+              <button
+                key={each}
+                id={`${id}-${each}`}
+                type="button"
+                role="tab"
+                aria-selected={selected}
+                aria-controls={`${id}-panel`}
+                onClick={() => setPage(each)}
+                className={`flex h-8 items-center gap-2 rounded-lg px-2.5 text-left font-medium text-sm transition-colors ${
+                  selected ? "bg-sunken text-ink" : "text-ink-soft hover:bg-sunken hover:text-ink"
+                }`}
+              >
+                <Icon aria-hidden size={15} className="shrink-0" />
+                {s[each]}
+              </button>
+            );
+          })}
+        </div>
+        <div
+          id={`${id}-panel`}
+          role="tabpanel"
+          aria-labelledby={`${id}-${page}`}
+          className="flex min-w-0 flex-1 flex-col gap-6"
+        >
+          {page === "general" && <GeneralSettings />}
+          {page === "chat" && <ChatSettings />}
+          {page === "appearance" && <AppearanceSettings />}
+          {page === "about" && <AboutSettings />}
+        </div>
       </div>
     </Dialog>
   );
diff --git a/app/src/features/account/account.test.tsx b/app/src/features/account/account.test.tsx
index d4871001..378c9d2f 100644
--- a/app/src/features/account/account.test.tsx
+++ b/app/src/features/account/account.test.tsx
@@ -90,11 +90,18 @@ describe("account area", () => {
     await openAccount();
     fireEvent.click(screen.getByRole("menuitem", { name: "Settings" }));
     const dialog = screen.getByRole("dialog", { name: "Settings" });
+    fireEvent.click(within(dialog).getByRole("tab", { name: "Appearance" }));
     fireEvent.click(within(dialog).getByRole("radio", { name: "Dark" }));
     expect(document.documentElement.dataset.theme).toBe("dark");
-    fireEvent.click(within(dialog).getByRole("radio", { name: "Español" }));
+    fireEvent.click(within(dialog).getByRole("tab", { name: "General" }));
+    fireEvent.click(
+      within(dialog).getByRole("button", { name: "Language: System language: English" }),
+    );
+    fireEvent.click(within(dialog).getByRole("option", { name: "Español" }));
     expect(screen.getByRole("dialog", { name: "Configuración" })).toBeDefined();
-    fireEvent.click(screen.getByRole("radio", { name: /Idioma del sistema/ }));
+    fireEvent.click(screen.getByRole("button", { name: "Idioma: Español" }));
+    fireEvent.click(screen.getByRole("option", { name: /Idioma del sistema/ }));
+    fireEvent.click(screen.getByRole("tab", { name: "About" }));
     expect(screen.getByRole("dialog", { name: "Settings" }).textContent).toContain("Botloft 0.1.0");
   });
 
diff --git a/app/src/features/account/prefs.test.tsx b/app/src/features/account/prefs.test.tsx
new file mode 100644
index 00000000..50535b70
--- /dev/null
+++ b/app/src/features/account/prefs.test.tsx
@@ -0,0 +1,78 @@
+import { act, cleanup, fireEvent, screen, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { FakeBotloft } from "../../lib/fake";
+import { prefs, resetPrefs } from "../../shell/prefs";
+import { crewOpened, openBot, renderApp } from "../../test/app";
+import { reducedMotion } from "../../ui/motion";
+
+afterEach(() => {
+  cleanup();
+  resetPrefs();
+});
+
+async function scout() {
+  const fake = new FakeBotloft();
+  const ops = fake.addCrew("Ops");
+  const bot = fake.addBot(ops.id, "Scout", "Finds sources");
+  fake.setBotState(bot.id, "idle");
+  renderApp(fake);
+  await crewOpened("Ops");
+  openBot("Scout");
+  await screen.findByRole("list", { name: "Messages" });
+  return { fake, bot };
+}
+
+async function openSettings(page: string) {
+  fireEvent.click(await screen.findByRole("button", { name: /Ana Lima/ }));
+  fireEvent.click(screen.getByRole("menuitem", { name: "Settings" }));
+  const dialog = screen.getByRole("dialog", { name: "Settings" });
+  fireEvent.click(within(dialog).getByRole("tab", { name: page }));
+  return dialog;
+}
+
+const sends = (fake: FakeBotloft) => fake.calls.filter((call) => call.method === "messages.send");
+
+describe("the app's own choices", () => {
+  test("Ctrl+Enter sends and Enter starts a line, when chosen", async () => {
+    const { fake } = await scout();
+    const dialog = await openSettings("Chat");
+    fireEvent.click(within(dialog).getByRole("switch", { name: "Enter sends the message" }));
+    expect(dialog.textContent).toContain("Enter starts a new line, and Ctrl+Enter sends.");
+    fireEvent.click(within(dialog).getByRole("button", { name: "Close" }));
+
+    const field = screen.getByLabelText("Message to Scout");
+    fireEvent.change(field, { target: { value: "two\nlines" } });
+    expect(screen.getByText("Ctrl+Enter to send, Enter for a new line")).toBeDefined();
+    fireEvent.keyDown(field, { key: "Enter" });
+    expect(sends(fake)).toHaveLength(0);
+    fireEvent.keyDown(field, { key: "Enter", ctrlKey: true });
+    const chat = screen.getByRole("list", { name: "Messages" });
+    expect(await within(chat).findByText(/two\s+lines/)).toBeDefined();
+    expect(sends(fake)).toHaveLength(1);
+  });
+
+  test("the browser and the screens stay behind their buttons, when chosen", async () => {
+    prefs.followBot.set(false);
+    const { fake, bot } = await scout();
+    act(() => {
+      fake.browser.open(bot.id, "https://example.com/", "Example");
+      fake.screens.draft(bot.id, "C:\\Work\\home.html", "<h1>Home");
+    });
+    expect(screen.queryByRole("complementary", { name: "Scout's browser" })).toBeNull();
+    expect(
+      screen.getByRole("button", { name: "Show browser: Scout is using the browser" }),
+    ).toBeDefined();
+    expect(screen.queryByRole("complementary", { name: /screens/i })).toBeNull();
+  });
+
+  test("less motion stills the window", async () => {
+    renderApp(new FakeBotloft());
+    const dialog = await openSettings("Appearance");
+    expect(reducedMotion()).toBe(false);
+    fireEvent.click(within(dialog).getByRole("switch", { name: "Less motion" }));
+    expect(document.documentElement.dataset.motion).toBe("less");
+    expect(reducedMotion()).toBe(true);
+    fireEvent.click(within(dialog).getByRole("switch", { name: "Less motion" }));
+    expect(document.documentElement.dataset.motion).toBeUndefined();
+  });
+});
diff --git a/app/src/features/account/settings.test.tsx b/app/src/features/account/settings.test.tsx
index cf4be40d..58bd4ff4 100644
--- a/app/src/features/account/settings.test.tsx
+++ b/app/src/features/account/settings.test.tsx
@@ -5,11 +5,11 @@ import type { Client } from "../../lib/client";
 import { FakeBotloft } from "../../lib/fake";
 import { FakeHost, FakeUpdate } from "../../lib/fakeHost";
 import { RpcError } from "../../lib/rpc";
-import { setWhenClosed } from "../../shell/closing";
+import { prefs, resetPrefs } from "../../shell/prefs";
 
 afterEach(() => {
   cleanup();
-  setWhenClosed("keep");
+  resetPrefs();
 });
 
 function renderApp(fake = new FakeBotloft(), host = new FakeHost()) {
@@ -74,6 +74,7 @@ describe("settings", () => {
   test("about looks for a new version on request", async () => {
     const { host } = renderApp();
     const dialog = await openSettings();
+    fireEvent.click(within(dialog).getByRole("tab", { name: "About" }));
     fireEvent.click(within(dialog).getByRole("button", { name: "Check for updates" }));
     expect(await within(dialog).findByText("You have the latest version.")).toBeDefined();
     host.update = new FakeUpdate("9.9.9");
@@ -96,7 +97,7 @@ describe("closing the window", () => {
   test("stops the bots, with the window out of sight first, when chosen", async () => {
     const { host } = renderApp();
     await screen.findByRole("heading", { name: "Welcome to Botloft" });
-    setWhenClosed("stop");
+    prefs.whenClosed.set("stop");
     await act(() => host.requestClose());
     expect(host.hidden).toBe(true);
     expect(host.stops).toBe(1);
@@ -104,7 +105,7 @@ describe("closing the window", () => {
   });
 
   test("opening Botloft again starts the bots it stopped", async () => {
-    setWhenClosed("stop");
+    prefs.whenClosed.set("stop");
     const host = new FakeHost();
     host.status = { state: "stopped", port: 45710, home: "C:\\data" };
     let finish: () => void = () => {};
diff --git a/app/src/features/bots/useFollowBot.ts b/app/src/features/bots/useFollowBot.ts
index 0ae6a9b7..bcb84263 100644
--- a/app/src/features/bots/useFollowBot.ts
+++ b/app/src/features/bots/useFollowBot.ts
@@ -3,10 +3,12 @@
 // hand opens the browser (spec 21.8), and a screen it starts writing opens
 // the design area (spec 22.5), whatever panel was open. Each opens once per
 // start; closing it leaves the button's dot. The browser in the owner's
-// hands is never taken away.
+// hands is never taken away. The owner can turn this off in Settings
+// (`prefs.followBot`): then only the buttons' dots say so.
 
 import { useEffect, useRef } from "react";
 import type { Bot } from "../../lib/protocol.gen";
+import { prefs } from "../../shell/prefs";
 import { useApp } from "../../store/context";
 
 export type Followed = "browser" | "screens";
@@ -44,7 +46,7 @@ export function useFollowBot({
     const was = before.current ?? { browsing, asking: false };
     before.current = { browsing, asking };
     if ((asking && !was.asking) || (browsing && !was.browsing)) {
-      if (side !== "browser") {
+      if (side !== "browser" && prefs.followBot.get()) {
         open("browser");
       }
     }
@@ -57,7 +59,7 @@ export function useFollowBot({
       return;
     }
     drawn.current.add(path);
-    if (side === "screens" || (held && side === "browser")) {
+    if (side === "screens" || (held && side === "browser") || !prefs.followBot.get()) {
       return;
     }
     open("screens");
diff --git a/app/src/features/chat/ChatComposer.tsx b/app/src/features/chat/ChatComposer.tsx
index 2fc1a641..fc524195 100644
--- a/app/src/features/chat/ChatComposer.tsx
+++ b/app/src/features/chat/ChatComposer.tsx
@@ -1,5 +1,7 @@
 // Writing to the bot: text, and files picked, pasted or dropped on the
-// chat. Enter sends and Shift+Enter starts a new line (spec 15.1).
+// chat. Enter sends and Shift+Enter starts a new line, or, if the owner
+// chose so in Settings, Ctrl+Enter sends and Enter starts a line (spec
+// 15.1).
 
 import { ArrowUp, File as FileIcon, Paperclip, X } from "lucide-react";
 import {
@@ -16,6 +18,7 @@ import { useT } from "../../i18n";
 import { errorText } from "../../lib/api";
 import { fileSize } from "../../lib/format";
 import { type Bot, FIELD_LIMITS } from "../../lib/protocol.gen";
+import { prefs, usePref } from "../../shell/prefs";
 import { useApi } from "../../store/context";
 import { rememberImage } from "./images";
 import { ModelPicker } from "./ModelPicker";
@@ -126,8 +129,13 @@ export function ChatComposer({
     }
   };
 
+  const enterSends = usePref(prefs.enterSends);
   const onKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>) => {
-    if (event.key === "Enter" && !event.shiftKey && !event.nativeEvent.isComposing) {
+    if (event.key !== "Enter" || event.nativeEvent.isComposing) {
+      return;
+    }
+    const withCtrl = event.ctrlKey || event.metaKey;
+    if (enterSends ? !event.shiftKey : withCtrl) {
       event.preventDefault();
       void send();
     }
@@ -200,7 +208,7 @@ export function ChatComposer({
           >
             {tooLong
               ? t.chat.composer.tooLong(text.length, FIELD_LIMITS.message)
-              : text && t.chat.composer.keys}
+              : text && (enterSends ? t.chat.composer.keys : t.chat.composer.keysWithCtrl)}
           </span>
           <ModelPicker bot={bot} onLater={setLater} />
           <button
diff --git a/app/src/features/onboarding/Welcome.tsx b/app/src/features/onboarding/Welcome.tsx
index f2680bdc..fe5311f1 100644
--- a/app/src/features/onboarding/Welcome.tsx
+++ b/app/src/features/onboarding/Welcome.tsx
@@ -1,7 +1,7 @@
 import { CircleCheck, CircleX, LoaderCircle, Plus } from "lucide-react";
 import { type ReactNode, useState } from "react";
 import { useT } from "../../i18n";
-import { useWhenClosed } from "../../shell/closing";
+import { prefs, usePref } from "../../shell/prefs";
 import { useApp } from "../../store/context";
 import { Button } from "../../ui/Button";
 import { useDaemonSettings } from "../account/useDaemonSettings";
@@ -15,7 +15,7 @@ export function Welcome() {
   const w = useT().onboarding.welcome;
   const system = useApp((state) => state.system);
   const [creating, setCreating] = useState(false);
-  const whenClosed = useWhenClosed();
+  const whenClosed = usePref(prefs.whenClosed);
   const { settings } = useDaemonSettings();
   const running =
     whenClosed === "stop"
diff --git a/app/src/features/onboarding/link.ts b/app/src/features/onboarding/link.ts
index eb4b2092..7c2cc16b 100644
--- a/app/src/features/onboarding/link.ts
+++ b/app/src/features/onboarding/link.ts
@@ -10,7 +10,7 @@ import { errorText } from "../../lib/api";
 import type { Client } from "../../lib/client";
 import type { DaemonStatus, Host } from "../../lib/host";
 import { PROTOCOL_VERSION } from "../../lib/protocol.gen";
-import { whenClosed } from "../../shell/closing";
+import { prefs } from "../../shell/prefs";
 
 export type LinkStep =
   | { step: "checking" }
@@ -100,7 +100,7 @@ export function createLink(host: Host, connect: Connect): StoreApi<Link> {
         case "stopped":
           if (mayChange) {
             // Closing Botloft stopped the bots: opening it brings them back.
-            const action = whenClosed() === "stop" ? "start" : "install";
+            const action = prefs.whenClosed.get() === "stop" ? "start" : "install";
             await change(run, action, () => host.installDaemon());
             return;
           }
diff --git a/app/src/features/routines/routines.test.tsx b/app/src/features/routines/routines.test.tsx
index b090b010..f9fbb878 100644
--- a/app/src/features/routines/routines.test.tsx
+++ b/app/src/features/routines/routines.test.tsx
@@ -87,6 +87,7 @@ describe("routines", () => {
     expect(screen.getByRole("tab", { name: "Routines (1)" })).toBeDefined();
   });
 
+  // Many steps through the form: slow when the whole suite runs at once.
   test("chosen days, intervals and cron become their schedules", async () => {
     const { fake } = await openRoutines();
     let dialog = newRoutine("Two days");
@@ -121,7 +122,7 @@ describe("routines", () => {
       schedule: { kind: "cron", expr: "0 2 * * *" },
       overlap: "queue",
     });
-  });
+  }, 15_000);
 
   test("a refusal the daemon explains is worded in the owner's language", async () => {
     const { fake } = await openRoutines();
diff --git a/app/src/i18n/en/account.ts b/app/src/i18n/en/account.ts
index f4210bf7..0d3b7d4c 100644
--- a/app/src/i18n/en/account.ts
+++ b/app/src/i18n/en/account.ts
@@ -42,6 +42,17 @@ export const account = {
     keepAwake: "Keep the computer awake while bots work",
     keepAwakeHint: "It still sleeps when you close the lid or choose Sleep.",
     saveFailed: "Could not change the setting",
+    pages: "Parts of Settings",
+    general: "General",
+    chat: "Chat",
+    enterSends: "Enter sends the message",
+    enterSendsOn: "Shift+Enter starts a new line.",
+    enterSendsOff: "Enter starts a new line, and Ctrl+Enter sends.",
+    followBot: "Open the browser and screens when a bot starts using them",
+    followBotOn: "The panel opens beside the chat, so you see what the bot does.",
+    followBotOff: "The panel's button gets a dot, and you open it when you want.",
+    lessMotion: "Less motion",
+    lessMotionHint: "A still window, as when the Windows animation effects are off.",
     appearance: "Appearance",
     theme: "Theme",
     themes: { system: "System", light: "Light", dark: "Dark" },
diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts
index f44a0594..30ef29c9 100644
--- a/app/src/i18n/en/chat.ts
+++ b/app/src/i18n/en/chat.ts
@@ -23,6 +23,7 @@ export const chat = {
     attachHint: "Attach files (or paste, or drop them on the chat)",
     tooLong: (length: number, max: number) => `${length}/${max} characters`,
     keys: "Enter to send, Shift+Enter for a new line",
+    keysWithCtrl: "Ctrl+Enter to send, Enter for a new line",
     send: "Send",
   },
   files: {
diff --git a/app/src/i18n/es/account.ts b/app/src/i18n/es/account.ts
index 61c05369..3ee3f349 100644
--- a/app/src/i18n/es/account.ts
+++ b/app/src/i18n/es/account.ts
@@ -42,6 +42,18 @@ export const account: Messages["account"] = {
     keepAwake: "Mantener el equipo despierto mientras los bots trabajan",
     keepAwakeHint: "Igual se suspende si cierras la tapa o eliges Suspender.",
     saveFailed: "No se pudo cambiar el ajuste",
+    pages: "Partes de la configuración",
+    general: "General",
+    chat: "Chat",
+    enterSends: "Enter envía el mensaje",
+    enterSendsOn: "Shift+Enter empieza una nueva línea.",
+    enterSendsOff: "Enter empieza una nueva línea, y Ctrl+Enter envía.",
+    followBot: "Abrir el navegador y las pantallas cuando un bot empiece a usarlos",
+    followBotOn: "El panel se abre junto al chat, para que veas lo que hace el bot.",
+    followBotOff: "El botón del panel muestra un punto, y lo abres cuando quieras.",
+    lessMotion: "Menos animaciones",
+    lessMotionHint:
+      "La ventana queda quieta, como cuando los efectos de animación de Windows están desactivados.",
     appearance: "Apariencia",
     theme: "Tema",
     themes: { system: "Sistema", light: "Claro", dark: "Oscuro" },
diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts
index e8059ede..a69002a1 100644
--- a/app/src/i18n/es/chat.ts
+++ b/app/src/i18n/es/chat.ts
@@ -23,6 +23,7 @@ export const chat: Messages["chat"] = {
     attachHint: "Adjuntar archivos (o pégalos, o suéltalos en el chat)",
     tooLong: (length: number, max: number) => `${length}/${max} caracteres`,
     keys: "Enter para enviar, Shift+Enter para una nueva línea",
+    keysWithCtrl: "Ctrl+Enter para enviar, Enter para una nueva línea",
     send: "Enviar",
   },
   files: {
diff --git a/app/src/i18n/pt-BR/account.ts b/app/src/i18n/pt-BR/account.ts
index b371a93a..66885f54 100644
--- a/app/src/i18n/pt-BR/account.ts
+++ b/app/src/i18n/pt-BR/account.ts
@@ -43,6 +43,18 @@ export const account: Messages["account"] = {
     keepAwake: "Não deixar o computador dormir enquanto os bots trabalham",
     keepAwakeHint: "Ele ainda dorme quando você fecha a tampa ou escolhe Suspender.",
     saveFailed: "Não foi possível mudar a configuração",
+    pages: "Partes das configurações",
+    general: "Geral",
+    chat: "Conversa",
+    enterSends: "Enter envia a mensagem",
+    enterSendsOn: "Shift+Enter começa uma nova linha.",
+    enterSendsOff: "Enter começa uma nova linha, e Ctrl+Enter envia.",
+    followBot: "Abrir o navegador e as telas quando um bot começar a usar",
+    followBotOn: "O painel abre ao lado da conversa, para você ver o que o bot faz.",
+    followBotOff: "O botão do painel ganha um ponto, e você abre quando quiser.",
+    lessMotion: "Menos animações",
+    lessMotionHint:
+      "A janela fica parada, como quando os efeitos de animação do Windows estão desligados.",
     appearance: "Aparência",
     theme: "Tema",
     themes: { system: "Sistema", light: "Claro", dark: "Escuro" },
diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts
index a25f1513..62d4a9d1 100644
--- a/app/src/i18n/pt-BR/chat.ts
+++ b/app/src/i18n/pt-BR/chat.ts
@@ -23,6 +23,7 @@ export const chat: Messages["chat"] = {
     attachHint: "Anexar arquivos (ou cole, ou solte no chat)",
     tooLong: (length: number, max: number) => `${length}/${max} caracteres`,
     keys: "Enter para enviar, Shift+Enter para uma nova linha",
+    keysWithCtrl: "Ctrl+Enter para enviar, Enter para uma nova linha",
     send: "Enviar",
   },
   files: {
diff --git a/app/src/index.css b/app/src/index.css
index 65c06f55..6baa10b3 100644
--- a/app/src/index.css
+++ b/app/src/index.css
@@ -8,6 +8,7 @@
 @import "./mascot.css";
 @import "./mascot-flame.css";
 @import "./panels.css";
+@import "./motion-less.css";
 
 /* Colors are tokens so the light and dark themes swap in one place
    (spec 15.3). State colors always go with an icon and a label. */
diff --git a/app/src/main.tsx b/app/src/main.tsx
index 76bde7fa..3173c76a 100644
--- a/app/src/main.tsx
+++ b/app/src/main.tsx
@@ -6,6 +6,7 @@ import type { Connect } from "./features/onboarding/link";
 import { connect, rpcUrl } from "./lib/client";
 import type { Host } from "./lib/host";
 import { tauriHost } from "./lib/tauriHost";
+import { prefs } from "./shell/prefs";
 import { currentZoom } from "./shell/zoom";
 import "./index.css";
 
@@ -30,8 +31,12 @@ async function props(): Promise<{ host: Host; connect: Connect }> {
 }
 
 props().then(({ host, connect: open }) => {
-  // Before the first paint, so the window never flashes at the small size.
+  // Before the first paint, so the window never flashes at the small size
+  // nor moves when the owner asked for less motion.
   host.setZoom(currentZoom()).catch(() => {});
+  if (prefs.lessMotion.get()) {
+    document.documentElement.dataset.motion = "less";
+  }
   createRoot(root).render(
     <StrictMode>
       <App host={host} connect={open} />
diff --git a/app/src/motion-less.css b/app/src/motion-less.css
new file mode 100644
index 00000000..1bb3170e
--- /dev/null
+++ b/app/src/motion-less.css
@@ -0,0 +1,25 @@
+/* "Less motion" in Settings (spec 15.3): the same as Windows asking for
+   it (the end of motion.css), for an owner who wants a still window
+   without changing Windows. */
+
+/* biome-ignore-start lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */
+:root[data-motion="less"] *,
+:root[data-motion="less"] *::before,
+:root[data-motion="less"] *::after,
+:root[data-motion="less"] ::details-content {
+  animation-duration: 0.01ms !important;
+  animation-iteration-count: 1 !important;
+  transition-duration: 0.01ms !important;
+}
+
+:root[data-motion="less"]::view-transition-group(*),
+:root[data-motion="less"]::view-transition-old(*),
+:root[data-motion="less"]::view-transition-new(*) {
+  animation: none !important;
+}
+
+/* A still stretch would read as a broken line: light up all of it. */
+:root[data-motion="less"] .state-trace {
+  stroke-dasharray: none;
+}
+/* biome-ignore-end lint/complexity/noImportantStyles: less motion must win over every animation, inline delays included */
diff --git a/app/src/shell/closing.ts b/app/src/shell/closing.ts
index 82638b77..777088b6 100644
--- a/app/src/shell/closing.ts
+++ b/app/src/shell/closing.ts
@@ -1,51 +1,10 @@
 // What closing the window does (spec 15.1): Botloft keeps the bots working
-// in the background, or, if the owner chose so in Settings, stops them
-// until it opens again. The choice is this app's, kept in localStorage
-// like the theme.
+// in the background, or, if the owner chose so in Settings
+// (`prefs.whenClosed`), stops them until it opens again.
 
-import { useEffect, useSyncExternalStore } from "react";
+import { useEffect } from "react";
 import type { Host } from "../lib/host";
-
-export type WhenClosed = "keep" | "stop";
-
-const KEY = "botloft.whenClosed";
-const listeners = new Set<() => void>();
-
-function stored(): WhenClosed {
-  try {
-    return localStorage.getItem(KEY) === "stop" ? "stop" : "keep";
-  } catch {
-    return "keep";
-  }
-}
-
-let choice: WhenClosed = stored();
-
-/** The owner's choice, for code outside React. */
-export function whenClosed(): WhenClosed {
-  return choice;
-}
-
-export function setWhenClosed(next: WhenClosed): void {
-  choice = next;
-  try {
-    localStorage.setItem(KEY, next);
-  } catch {
-    // Private storage off: the choice lasts for this window.
-  }
-  for (const listener of listeners) {
-    listener();
-  }
-}
-
-function subscribe(listener: () => void): () => void {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-
-export function useWhenClosed(): WhenClosed {
-  return useSyncExternalStore(subscribe, () => choice);
-}
+import { prefs } from "./prefs";
 
 /**
  * Stops the bots as the window closes, when the owner chose so. The window
@@ -58,7 +17,7 @@ export function useCloseBehavior(host: Host): void {
     let alive = true;
     host.window
       .onCloseRequested(async () => {
-        if (choice !== "stop") {
+        if (prefs.whenClosed.get() !== "stop") {
           return;
         }
         await host.window.hide().catch(() => {});
diff --git a/app/src/shell/motionRoot.ts b/app/src/shell/motionRoot.ts
new file mode 100644
index 00000000..05b5f39f
--- /dev/null
+++ b/app/src/shell/motionRoot.ts
@@ -0,0 +1,16 @@
+// "Less motion" in Settings (spec 15.3): marks the root, which
+// `motion-less.css` and `reducedMotion()` follow.
+
+import { useEffect } from "react";
+import { prefs, usePref } from "./prefs";
+
+export function useMotionRoot(): void {
+  const less = usePref(prefs.lessMotion);
+  useEffect(() => {
+    if (less) {
+      document.documentElement.dataset.motion = "less";
+    } else {
+      delete document.documentElement.dataset.motion;
+    }
+  }, [less]);
+}
diff --git a/app/src/shell/prefs.ts b/app/src/shell/prefs.ts
new file mode 100644
index 00000000..72bdd9db
--- /dev/null
+++ b/app/src/shell/prefs.ts
@@ -0,0 +1,71 @@
+// The owner's choices that belong to this app and not to the daemon (spec
+// 15.1): kept in localStorage, like the theme, and read at once where they
+// apply.
+
+import { useSyncExternalStore } from "react";
+
+type Value = string | boolean;
+
+export interface Pref<T extends Value> {
+  get(): T;
+  set(value: T): void;
+  subscribe(listener: () => void): () => void;
+  /** Back to the default, for tests. */
+  reset(): void;
+}
+
+function pref<T extends Value>(key: string, fallback: T, allowed: readonly T[]): Pref<T> {
+  const listeners = new Set<() => void>();
+  const read = (): T => {
+    try {
+      const text = localStorage.getItem(key);
+      return allowed.find((value) => String(value) === text) ?? fallback;
+    } catch {
+      return fallback;
+    }
+  };
+  let current = read();
+  const set = (value: T) => {
+    current = value;
+    try {
+      localStorage.setItem(key, String(value));
+    } catch {
+      // Private storage off: the choice lasts for this window.
+    }
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  return {
+    get: () => current,
+    set,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    reset: () => set(fallback),
+  };
+}
+
+const ON_OFF = [true, false] as const;
+
+export const prefs = {
+  /** What closing the window does: the bots keep working, or stop. */
+  whenClosed: pref<"keep" | "stop">("botloft.whenClosed", "keep", ["keep", "stop"]),
+  /** Enter sends a message; off, Ctrl+Enter does and Enter starts a line. */
+  enterSends: pref<boolean>("botloft.enterSends", true, ON_OFF),
+  /** The browser and the screens open by themselves when a bot starts on them. */
+  followBot: pref<boolean>("botloft.followBot", true, ON_OFF),
+  /** No motion in the window, whatever Windows says. */
+  lessMotion: pref<boolean>("botloft.lessMotion", false, ON_OFF),
+};
+
+export function usePref<T extends Value>(choice: Pref<T>): T {
+  return useSyncExternalStore(choice.subscribe, choice.get);
+}
+
+export function resetPrefs(): void {
+  for (const choice of Object.values(prefs)) {
+    choice.reset();
+  }
+}
diff --git a/app/src/shell/zoom.test.tsx b/app/src/shell/zoom.test.tsx
index f9c611bb..017bb052 100644
--- a/app/src/shell/zoom.test.tsx
+++ b/app/src/shell/zoom.test.tsx
@@ -32,6 +32,7 @@ describe("app size", () => {
     await screen.findByRole("heading", { name: "Welcome to Botloft" });
     fireEvent.click(screen.getByRole("button", { name: /Ana Lima/ }));
     fireEvent.click(screen.getByRole("menuitem", { name: "Settings" }));
+    fireEvent.click(screen.getByRole("tab", { name: "Appearance" }));
     const sizes = screen.getByRole("radiogroup", { name: "Size" });
     expect(
       (within(sizes).getByRole("radio", { name: "125% (default)" }) as HTMLInputElement).checked,
diff --git a/app/src/ui/Select.tsx b/app/src/ui/Select.tsx
new file mode 100644
index 00000000..48a0bcb9
--- /dev/null
+++ b/app/src/ui/Select.tsx
@@ -0,0 +1,130 @@
+import { Check, ChevronDown } from "lucide-react";
+import { type KeyboardEvent, useCallback, useEffect, useId, useRef, useState } from "react";
+import { POPOVER, POPOVER_ITEM } from "./surface";
+import { useDismiss } from "./useDismiss";
+
+/**
+ * A choice among several, shown as a button with the chosen one that
+ * opens the list under it, like the app's menus. The arrow keys move
+ * through the list, Enter picks, and Escape closes only the list, never
+ * the dialog around it.
+ */
+export function Select<T extends string>({
+  label,
+  value,
+  options,
+  onChange,
+}: {
+  label: string;
+  value: T;
+  options: readonly { value: T; label: string }[];
+  onChange(value: T): void;
+}) {
+  const [open, setOpen] = useState(false);
+  const root = useRef<HTMLDivElement>(null);
+  const trigger = useRef<HTMLButtonElement>(null);
+  const list = useRef<HTMLDivElement>(null);
+  const id = useId();
+  const chosen = options.find((option) => option.value === value);
+  const close = useCallback(() => setOpen(false), []);
+  useDismiss(open, root, close);
+
+  // The list opens on the chosen option, ready for the keyboard.
+  useEffect(() => {
+    if (open) {
+      list.current?.querySelector<HTMLElement>('[aria-selected="true"]')?.focus();
+    }
+  }, [open]);
+
+  const pick = (next: T) => {
+    setOpen(false);
+    trigger.current?.focus();
+    if (next !== value) {
+      onChange(next);
+    }
+  };
+
+  const onListKey = (event: KeyboardEvent<HTMLDivElement>) => {
+    const items = [...(list.current?.querySelectorAll<HTMLElement>('[role="option"]') ?? [])];
+    const at = items.indexOf(document.activeElement as HTMLElement);
+    const moves: Record<string, number> = {
+      ArrowDown: Math.min(items.length - 1, at + 1),
+      ArrowUp: Math.max(0, at - 1),
+      Home: 0,
+      End: items.length - 1,
+    };
+    if (event.key in moves) {
+      event.preventDefault();
+      items[moves[event.key] ?? 0]?.focus();
+    } else if (event.key === "Escape") {
+      event.preventDefault();
+      event.stopPropagation();
+      setOpen(false);
+      trigger.current?.focus();
+    } else if (event.key === "Tab") {
+      setOpen(false);
+    }
+  };
+
+  return (
+    <div ref={root} className="relative w-full max-w-72">
+      <button
+        ref={trigger}
+        type="button"
+        aria-haspopup="listbox"
+        aria-expanded={open}
+        aria-controls={open ? `${id}-list` : undefined}
+        aria-label={`${label}: ${chosen?.label ?? ""}`}
+        onClick={() => setOpen(!open)}
+        onKeyDown={(event) => {
+          if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+            event.preventDefault();
+            setOpen(true);
+          }
+        }}
+        className="flex h-8 w-full items-center justify-between gap-2 rounded-lg border border-line-strong bg-panel px-3 text-left text-sm hover:bg-sunken"
+      >
+        <span className="truncate">{chosen?.label}</span>
+        <ChevronDown
+          aria-hidden
+          size={14}
+          className={`shrink-0 text-muted transition-transform duration-150 ${open ? "rotate-180" : ""}`}
+        />
+      </button>
+      {open && (
+        <div
+          ref={list}
+          id={`${id}-list`}
+          role="listbox"
+          aria-label={label}
+          tabIndex={-1}
+          onKeyDown={onListKey}
+          className={`absolute top-full left-0 mt-1 w-full origin-top ${POPOVER}`}
+        >
+          {options.map((option) => {
+            const selected = option.value === value;
+            return (
+              <div
+                key={option.value}
+                role="option"
+                aria-selected={selected}
+                tabIndex={-1}
+                onClick={() => pick(option.value)}
+                onKeyDown={(event) => {
+                  if (event.key === "Enter" || event.key === " ") {
+                    event.preventDefault();
+                    pick(option.value);
+                  }
+                }}
+                className={`h-8 cursor-pointer focus:bg-sunken focus:outline-none ${POPOVER_ITEM}`}
+              >
+                <Check aria-hidden size={14} className={selected ? "" : "invisible"} />
+                <span className="truncate">{option.label}</span>
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/app/src/ui/motion.ts b/app/src/ui/motion.ts
index f1f26b3a..5f05ee98 100644
--- a/app/src/ui/motion.ts
+++ b/app/src/ui/motion.ts
@@ -5,11 +5,15 @@
 import { createContext, useContext } from "react";
 import { flushSync } from "react-dom";
 
-/** Whether Windows asked for less motion ("Animation effects" off). */
+/**
+ * Whether Windows asked for less motion ("Animation effects" off), or the
+ * owner did in Settings (`data-motion` on the root).
+ */
 export function reducedMotion(): boolean {
   return (
-    typeof window.matchMedia === "function" &&
-    window.matchMedia("(prefers-reduced-motion: reduce)").matches
+    document.documentElement.dataset.motion === "less" ||
+    (typeof window.matchMedia === "function" &&
+      window.matchMedia("(prefers-reduced-motion: reduce)").matches)
   );
 }
 
diff --git a/app/src/ui/select.test.tsx b/app/src/ui/select.test.tsx
new file mode 100644
index 00000000..69a9edea
--- /dev/null
+++ b/app/src/ui/select.test.tsx
@@ -0,0 +1,63 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { useState } from "react";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { Dialog } from "./Dialog";
+import { Select } from "./Select";
+
+afterEach(cleanup);
+
+const LANGUAGES = [
+  { value: "system", label: "System language: English" },
+  { value: "en", label: "English" },
+  { value: "pt-BR", label: "Português (Brasil)" },
+  { value: "es", label: "Español" },
+] as const;
+
+type Language = (typeof LANGUAGES)[number]["value"];
+
+function Picker({ onClose }: { onClose(): void }) {
+  const [value, setValue] = useState<Language>("system");
+  return (
+    <Dialog title="Settings" onClose={onClose}>
+      <Select<Language> label="Language" value={value} options={LANGUAGES} onChange={setValue} />
+    </Dialog>
+  );
+}
+
+const trigger = () => screen.getByRole("button", { name: /^Language:/ });
+
+describe("a dropdown", () => {
+  test("shows the choice and picks another with a click", () => {
+    render(<Picker onClose={() => {}} />);
+    expect(trigger().getAttribute("aria-label")).toBe("Language: System language: English");
+    fireEvent.click(trigger());
+    expect(
+      screen
+        .getByRole("option", { name: "System language: English" })
+        .getAttribute("aria-selected"),
+    ).toBe("true");
+    fireEvent.click(screen.getByRole("option", { name: "Español" }));
+    expect(screen.queryByRole("listbox")).toBeNull();
+    expect(trigger().getAttribute("aria-label")).toBe("Language: Español");
+  });
+
+  test("works from the keyboard, and Escape closes only the list", () => {
+    const onClose = vi.fn();
+    render(<Picker onClose={onClose} />);
+    fireEvent.keyDown(trigger(), { key: "ArrowDown" });
+    const list = screen.getByRole("listbox", { name: "Language" });
+    expect(document.activeElement?.textContent).toBe("System language: English");
+    fireEvent.keyDown(list, { key: "ArrowDown" });
+    fireEvent.keyDown(list, { key: "ArrowDown" });
+    expect(document.activeElement?.textContent).toBe("Português (Brasil)");
+    fireEvent.keyDown(document.activeElement as Element, { key: "Enter" });
+    expect(trigger().getAttribute("aria-label")).toBe("Language: Português (Brasil)");
+    expect(document.activeElement).toBe(trigger());
+
+    fireEvent.click(trigger());
+    fireEvent.keyDown(document.activeElement as Element, { key: "Escape" });
+    expect(screen.queryByRole("listbox")).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(screen.getByRole("dialog", { name: "Settings" })).toBeDefined();
+  });
+});
diff --git a/docs/spec.md b/docs/spec.md
index fa10a498..3cace08c 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -620,8 +620,8 @@ Layout, como um app de mensagens:
 
 - **Barra lateral:** crews como seções, com os bots como conversas. Cada conversa mostra avatar, nome, estado (cor, ícone e texto) e a prévia da última atividade (`lastActivity`) com a hora. Ela aparece desde a conexão, também na tela de boas-vindas antes da primeira crew.
 - **Área da conta**, no pé da barra lateral, como nos apps de chat: um círculo com a inicial, o nome do dono (do Windows) e o plano do Claude ("Plano Max"; sem plano, a organização ou o e-mail; desconectado, "Sem conta do Claude conectada"). Um clique abre um menu para cima com o e-mail e: **Uso** (as janelas de uso do plano, 8.1, com a parte usada e quando renovam; antes da primeira resposta de um bot, um aviso de que ainda não há dados), **Configurações** (abaixo), **Idioma** (submenu ao lado, com a escolha na hora), **Novidades** (a página de releases no navegador) e **Ajuda** (o README no navegador). Tema, tamanho e idioma saíram da barra de título; ela só mostra o idioma nas telas de preparo, que ainda não têm barra lateral.
-- **Configurações**, um diálogo com quatro partes. **Em segundo plano**, três chaves, cada uma com uma linha que diz o que a escolha atual faz: "Continuar trabalhando depois de fechar o Botloft" (ligada, os bots seguem depois que a janela fecha; desligada, fechar a janela a esconde, chama `daemon_stop` e fecha, e os bots continuam de onde pararam quando o app abre de novo, com "Iniciando seus bots…" no lugar de "Preparando o Botloft…"; a escolha é do app, no `localStorage`, `botloft.whenClosed`), "Iniciar com o Windows" (`startWithWindows`, 14) e "Não deixar o computador dormir enquanto os bots trabalham" (`keepAwake`, com a linha de que a tampa e o Suspender ainda põem o computador para dormir). As duas do daemon vêm de `settings.get` ao abrir, mudam na hora na tela e voltam atrás, com um aviso, se `settings.update` falhar. **Aparência** (tema e tamanho), **Idioma** e **Sobre**: as versões do Botloft e do Claude Code, o e-mail e "Procurar atualizações", que consulta o feed na hora (15.5) e diz que esta é a versão mais recente ou mostra "Ver atualização", que abre o diálogo de atualizar. A linha do Botloft na tela de boas-vindas segue as mesmas escolhas.
-- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha (a dica aparece enquanto o dono escreve).
+- **Configurações**, um diálogo com as partes listadas à esquerda (abas verticais): **Geral**, **Conversa**, **Aparência** e **Sobre**. As escolhas que são só do app ficam no `localStorage` (`botloft.whenClosed`, `botloft.enterSends`, `botloft.followBot`, `botloft.lessMotion`), como o tema. Em Geral, primeiro o **Idioma**, numa lista suspensa (um botão com a escolha que abre a lista embaixo, no visual dos menus, com as setas, Enter e Esc, que fecha só a lista); depois **Em segundo plano**, três chaves, cada uma com uma linha que diz o que a escolha atual faz: "Continuar trabalhando depois de fechar o Botloft" (ligada, os bots seguem depois que a janela fecha; desligada, fechar a janela a esconde, chama `daemon_stop` e fecha, e os bots continuam de onde pararam quando o app abre de novo, com "Iniciando seus bots…" no lugar de "Preparando o Botloft…"; a escolha é do app), "Iniciar com o Windows" (`startWithWindows`, 14) e "Não deixar o computador dormir enquanto os bots trabalham" (`keepAwake`, com a linha de que a tampa e o Suspender ainda põem o computador para dormir). As duas do daemon vêm de `settings.get` ao abrir, mudam na hora na tela e voltam atrás, com um aviso, se `settings.update` falhar. Em Conversa, "Enter envia a mensagem" (desligada, Enter quebra a linha e Ctrl+Enter envia, e a dica do compositor diz isso) e "Abrir o navegador e as telas quando um bot começar a usar" (desligada, só o ponto no botão avisa). Em Aparência, tema, tamanho e "Menos animações", que marca a raiz com `data-motion="less"` e para tudo como o Windows faria (15.3). Em **Sobre**: as versões do Botloft e do Claude Code, o e-mail e "Procurar atualizações", que consulta o feed na hora (15.5) e diz que esta é a versão mais recente ou mostra "Ver atualização", que abre o diálogo de atualizar. A linha do Botloft na tela de boas-vindas segue as mesmas escolhas.
+- **Área principal com um bot:** cabeçalho com nome, estado e ações; o chat; o compositor embaixo. O compositor aceita texto, colar imagem e arrastar ou escolher arquivos. Enter envia e Shift+Enter quebra linha, ou, se o dono escolheu nas Configurações, Ctrl+Enter envia e Enter quebra linha (a dica aparece enquanto o dono escreve).
 - **Modo do bot**, no compositor, ao lado do clipe, como no Claude Code: um botão com o modo atual abre um menu para cima, "Modo", com Automático, Manual, Aceitar edições e Plano, cada um com uma linha que fala do bot pelo nome ("Scout decide o que precisa do seu OK") e a marca no atual. Separado, "Ignorar permissões" com o botão Ativar, que abre uma confirmação dizendo que o bot não fica preso à pasta dele (13). Nesse modo o botão fica vermelho e o cabeçalho mostra "Não pergunta nada" em vermelho. Com o bot ocupado, uma linha acima do compositor avisa que ele muda de modo quando terminar o que está fazendo.
 - **Modelo do bot**, no compositor, ao lado do botão de enviar: mostra o modelo em uso ("Opus 5.5"; antes do primeiro turno, o nome escolhido ou "Padrão") e abre um menu para cima, "Modelo", com Padrão do plano, Fable, Opus, Sonnet e Haiku. Cada um tem uma linha que fala do bot pelo nome ("Scout fica rápido e capaz, bom para quase tudo"; o padrão diz qual modelo é hoje), e o pé do menu lembra que modelos mais capazes gastam o limite do plano mais rápido. A janela de criar e editar bot tem a mesma escolha. Com o bot ocupado, a mesma linha acima do compositor avisa que ele troca quando terminar.
 - **Área principal com uma crew:** a timeline (messages entre os bots e do dono) e as tasks. Embaixo do nome, "Trabalha em <pasta>", que abre a pasta no Explorer; o menu da crew tem "Abrir pasta de trabalho" e "Mudar pasta de trabalho…", que abre o seletor de pastas do Windows e confirma antes de mudar, avisando que cada bot reinicia quando terminar o que está fazendo.
@@ -629,7 +629,7 @@ Layout, como um app de mensagens:
 - **Chefe:** uma coroa ao lado do nome na barra lateral e nos cartões da crew, e "Chefe" no cabeçalho do bot, com a dica "Lidera <crew>: planeja o trabalho e sugere bots novos". O menu do bot tem "Tornar chefe da equipe" ou "Deixar de ser chefe".
 - **Sugestão de bot** (10.2): um cartão no chat do chefe, "<chefe> sugere um bot novo", com o porquê e os campos editáveis Nome, Modelo, Função e Instruções, a linha de que o bot começa na hora e recebe o trabalho do chefe, um campo para dizer ao chefe por que não, e os botões Criar bot e Agora não. Respondido, vira uma linha ("Você criou Designer", "Você recusou Designer") que abre o que foi sugerido.
 - **Detalhes do bot** (pasta, instruções, sessão) ficam num painel, fora do caminho da conversa. Detalhes e arquivos são painéis laterais que o dono redimensiona arrastando a borda esquerda (ou com as setas do teclado, Shift anda mais; duplo clique volta ao padrão): 256 a 900 px, sempre deixando ao chat ao menos 22rem, e a largura de cada um fica no `localStorage` (`botloft.panel.details`, `botloft.panel.files`, `botloft.panel.browser`, `botloft.panel.screens`). O chat encolhe com eles e nunca passa por baixo nem por cima do painel.
-- **Arquivos do bot** (8.4): um botão "Mostrar arquivos" no cabeçalho abre, à direita do chat, um painel com o que o bot fez, do mais novo ao mais antigo (ícone pelo tipo, nome, pasta, tamanho, "há 5 min"). Um clique mostra o arquivo no próprio painel: imagem, PDF, markdown e texto aparecem; o resto diz que não tem prévia. "Abrir" usa o programa que o Windows escolheu e "Mostrar na pasta" abre o Explorer com o arquivo marcado. A lista é lida ao abrir o bot, a cada 4 s enquanto ele trabalha e de novo quando ele para. Com o painel fechado, o botão ganha um contador dos arquivos que apareceram desde a última vez que o dono olhou; abertos, esses levam a etiqueta "Novo". No chat, a linha de uma ferramenta que mudou um arquivo (`Write`, `Edit`...; item `tool` com `file`, 8.2) e não falhou ganha o botão "Ver em arquivos", que abre o painel direto na prévia desse arquivo; se ele não existe mais, o painel diz. Detalhes, arquivos, o navegador (21.8) e as telas (22.5) dividem o mesmo lugar: abrir um fecha o outro. O painel abre deslizando da borda direita (460 ms, sem pressa no começo) e fecha voltando para ela (360 ms) antes de sair, com o conteúdo na largura final o tempo todo e o chat acompanhando; quem troca de painel começa da largura do anterior. Fechando, o painel já não recebe clique nem leitor de tela. Com movimento reduzido, abre e fecha de uma vez. O painel segue o que o bot começa a fazer, para o dono ver acontecer: o navegador abre quando o bot sobe o navegador ou pede uma mão (21.8), as telas quando ele começa a escrever uma (22.5), no lugar do painel que estiver aberto e uma vez por começo. Fechado pelo dono, fica fechado, com o ponto no botão. O navegador nas mãos do dono (21.10) nunca é trocado.
+- **Arquivos do bot** (8.4): um botão "Mostrar arquivos" no cabeçalho abre, à direita do chat, um painel com o que o bot fez, do mais novo ao mais antigo (ícone pelo tipo, nome, pasta, tamanho, "há 5 min"). Um clique mostra o arquivo no próprio painel: imagem, PDF, markdown e texto aparecem; o resto diz que não tem prévia. "Abrir" usa o programa que o Windows escolheu e "Mostrar na pasta" abre o Explorer com o arquivo marcado. A lista é lida ao abrir o bot, a cada 4 s enquanto ele trabalha e de novo quando ele para. Com o painel fechado, o botão ganha um contador dos arquivos que apareceram desde a última vez que o dono olhou; abertos, esses levam a etiqueta "Novo". No chat, a linha de uma ferramenta que mudou um arquivo (`Write`, `Edit`...; item `tool` com `file`, 8.2) e não falhou ganha o botão "Ver em arquivos", que abre o painel direto na prévia desse arquivo; se ele não existe mais, o painel diz. Detalhes, arquivos, o navegador (21.8) e as telas (22.5) dividem o mesmo lugar: abrir um fecha o outro. O painel abre deslizando da borda direita (460 ms, sem pressa no começo) e fecha voltando para ela (360 ms) antes de sair, com o conteúdo na largura final o tempo todo e o chat acompanhando; quem troca de painel começa da largura do anterior. Fechando, o painel já não recebe clique nem leitor de tela. Com movimento reduzido, abre e fecha de uma vez. O painel segue o que o bot começa a fazer, para o dono ver acontecer: o navegador abre quando o bot sobe o navegador ou pede uma mão (21.8), as telas quando ele começa a escrever uma (22.5), no lugar do painel que estiver aberto e uma vez por começo, a menos que o dono tenha desligado isso nas Configurações. Fechado pelo dono, fica fechado, com o ponto no botão. O navegador nas mãos do dono (21.10) nunca é trocado.
 
 ### 15.2 Comandos Tauri
 
@@ -671,7 +671,7 @@ Ferramenta de trabalho densa e calma: tipografia forte, grid firme, estados dos
 
 Tamanho: a janela inteira é desenhada numa escala (zoom do webview, `setZoom`), então texto, espaçamento, ícones e avatares crescem juntos. Níveis 100%, 110%, 125% e 150%; o padrão é **125%**, porque o desenho a 100% ficava miúdo num monitor sem ampliação do Windows. Quem já usa a ampliação alta volta para 100% em Configurações (área da conta) ou com Ctrl+-; Ctrl+= aumenta e Ctrl+0 volta ao padrão. A escolha fica no `localStorage` (`botloft.zoom`) e é aplicada antes da primeira pintura, para a janela não piscar pequena. Acima de 150% a janela mínima (900 px) não cabe o layout.
 
-Movimento: o app se mexe para parecer vivo, sem atrapalhar o trabalho. Animações curtas (150 a 400 ms, saída suave) em CSS, sem biblioteca (`motion.css`), e todas param quando o Windows desliga os efeitos de animação (`prefers-reduced-motion`).
+Movimento: o app se mexe para parecer vivo, sem atrapalhar o trabalho. Animações curtas (150 a 400 ms, saída suave) em CSS, sem biblioteca (`motion.css`), e todas param quando o Windows desliga os efeitos de animação (`prefers-reduced-motion`) ou quando o dono liga "Menos animações" nas Configurações (`motion-less.css` repete as mesmas regras para `:root[data-motion="less"]`, e `reducedMotion()` olha os dois).
 
 - **Mascote:** cada bot tem um humor que segue o estado, e a chama queima de verdade: o contorno muda de forma quadro a quadro e o sombreado acompanha (`mascot.css`, `mascot-flame.css`). Parado, a chama balança devagar; trabalhando (`busy`, `launching`), queima forte e solta faíscas pelo alto; esperando o dono (`needs_approval`), inclina rápido e dá pulinhos; no limite de uso, queima baixo, de pálpebras pesadas que caem de vez em quando; pausado ou parado, vira uma brasa pequena e dorme, de olhos fechados em dois arcos. Os olhos piscam fechando de cima e de baixo, cada bot num ritmo, para uma equipe não piscar junta. Mexem-se os mascotes da barra lateral, do cabeçalho, dos cartões da crew e da resposta em andamento; o histórico do chat fica parado. O humor soma ao estado, que continua com cor, ícone e texto.
 - **Chegadas:** o que chega enquanto o dono olha entra subindo e aparecendo: mensagens, ferramentas, pedidos, avisos e bots novos na barra lateral. O que já estava lá quando ele abriu o chat (ou o app) aparece parado, e páginas antigas carregadas em cima não se mexem. A resposta já aparece enquanto é escrita, então não anima de novo ao terminar.