Skip to content

Your lightweight open-source personal agent.

195 KB
Raw Blame
import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { Window as HappyWindow } from "happy-dom";

import i18n from "@/i18n";
import { DEFAULT_TRANSCRIPTION_SETTINGS } from "@/components/settings/capabilities/TranscriptionSettings";
import { useSessions } from "@/hooks/useSessions";
import type { RunState } from "@/lib/nanobot-client";
import { activateReloadCache, clearReloadCache, writeReloadCache } from "@/lib/reload-cache";
import type {
  ChatSummary,
  ConnectionStatus,
  SessionAutomationJob,
  SidebarStatePayload,
  WorkspaceScopePayload,
} from "@/lib/types";

(window as unknown as HappyWindow).happyDOM.settings.disableIframePageLoading = true;

const connectSpy = vi.fn();
const refreshSpy = vi.fn();
const createChatSpy = vi.fn().mockResolvedValue("chat-1");
const deleteChatSpy = vi.fn();
const getSessionAutomationsSpy = vi.fn<(key: string) => Promise<SessionAutomationJob[]>>();
const toggleThemeSpy = vi.fn();
const updateUrlSpy = vi.fn();
const attachSpy = vi.fn();
const setSidebarStateSpy = vi.fn();
const requestMutationSpy = vi.fn();
const discardTemporaryChatSpy = vi.fn();
const newTemporaryChatSpy = vi.fn<() => Promise<string>>();
const sendMessageSpy = vi.fn();
const sendSystemCommandSpy = vi.fn().mockResolvedValue(undefined);
let mockDefaultChatId: string | null = null;
const statusHandlers = new Set<(status: ConnectionStatus) => void>();
const runStatusHandlers = new Set<(chatId: string, state: RunState) => void>();
const runState = (startedAt: number | null): RunState => ({
  active: startedAt !== null, startedAt, latestTurnId: null, generation: 0, unsettled: false,
});
const sessionUpdateHandlers = new Set<(
  chatId: string,
  scope?: string,
  workspaceScope?: WorkspaceScopePayload,
) => void>();
const sidebarStateUpdateHandlers = new Set<(state: SidebarStatePayload) => void>();
const pairingChangeHandlers = new Set<() => void>();
const readyHandlers = new Set<() => void>();
let mockSessions: ChatSummary[] = [];
const HERO_GREETING_PATTERN =
  /What should we work on\?|Where should we start\?|What are we building today\?|What should we tackle together\?/;

function setNavigatorPlatform(platform: string): void {
  Object.defineProperty(window.navigator, "platform", {
    configurable: true,
    value: platform,
  });
}

function jsonResponse(body: unknown): Response {
  return {
    ok: true,
    status: 200,
    json: async () => body,
  } as Response;
}

function mockFetchRoutes(routes: Record<string, unknown>): void {
  vi.stubGlobal(
    "fetch",
    vi.fn(async (input: RequestInfo | URL) => {
      const route = routes[String(input)]
        ?? (String(input) === "/api/webui/sidebar-state" ? {} : undefined)
        ?? (/^\/api\/sessions\/[^/]+\/subagents$/.test(String(input)) ? { tasks: [] } : undefined);
      const body =
        typeof route === "function"
          ? await (route as () => unknown | Promise<unknown>)()
          : route;
      return body === undefined
        ? ({ ok: false, status: 404, json: async () => ({}) } as Response)
        : jsonResponse(body);
    }),
  );
}

function currentMonthTimestamp(day: number, hour = 10, minute = 0): number {
  const now = new Date();
  return new Date(now.getFullYear(), now.getMonth(), day, hour, minute).getTime();
}

function baseSettingsPayload() {
  return {
    agent: {
      model: "openai/gpt-4o",
      provider: "auto",
      resolved_provider: "openai",
      has_api_key: true,
      model_preset: "default",
      max_tokens: 8192,
      context_window_tokens: 65536,
      temperature: 0.1,
      reasoning_effort: null,
      timezone: "UTC",
      tool_hint_max_length: 40,
    },
    model_presets: [{
      name: "default",
      label: "Default",
      active: true,
      is_default: true,
      model: "openai/gpt-4o",
      provider: "auto",
      max_tokens: 8192,
      context_window_tokens: 65536,
      temperature: 0.1,
      reasoning_effort: null,
    }],
    model_call_order: [],
    model_call_order_editable: false,
    providers: [],
    web_search: {
      provider: "duckduckgo",
      api_key_hint: null,
      base_url: null,
      max_results: 5,
      timeout: 30,
      providers: [{ name: "duckduckgo", label: "DuckDuckGo", credential: "none" }],
    },
    web: {
      enable: true,
      use_proxy: false,
      user_agent: null,
      search: { max_results: 5, timeout: 30 },
      fetch: { use_jina_reader: true },
    },
    image_generation: {
      enabled: false,
      provider: "openrouter",
      provider_configured: false,
      model: "openai/gpt-5.4-image-2",
      default_aspect_ratio: "1:1",
      default_image_size: "1K",
      max_images_per_turn: 4,
      save_dir: "generated",
      providers: [],
    },
    runtime: {
      config_path: "/tmp/config.json",
      workspace_path: "/tmp/workspace",
      gateway_host: "127.0.0.1",
      gateway_port: 18790,
      heartbeat: {
        enabled: true,
        interval_s: 1800,
      },
      dream: {
        schedule: "every 2h",
      },
      unified_session: false,
    },
    advanced: {
      restrict_to_workspace: false,
      webui_allow_local_service_access: true,
      webui_default_access_mode: "default",
      private_service_protection_enabled: true,
      ssrf_whitelist_count: 0,
      mcp_server_count: 0,
      exec_enabled: true,
      exec_sandbox: null,
      exec_path_prepend_set: false,
      exec_path_append_set: false,
    },
    requires_restart: false,
  };
}

vi.mock("@/hooks/useSessions", async (importOriginal) => {
  const React = await import("react");
  const actual = await importOriginal<typeof import("@/hooks/useSessions")>();
  return {
    ...actual,
    useSessions: vi.fn(function useMockSessions() {
      const [sessions, setSessions] = React.useState(mockSessions);
      return {
        sessions,
        loading: false,
        error: null,
        refresh: refreshSpy,
        createChat: async (scope?: WorkspaceScopePayload | null) => {
          const chatId = await createChatSpy(scope);
          const now = new Date().toISOString();
          setSessions((prev: ChatSummary[]) => [
            {
              key: `websocket:${chatId}`,
              channel: "websocket",
              chatId,
              createdAt: now,
              updatedAt: now,
              title: "",
              preview: "",
              workspaceScope: scope ?? null,
            },
            ...prev.filter((session) => session.chatId !== chatId),
          ]);
          return chatId;
        },
        forkChat: async () => "fork-chat",
        getSessionAutomations: getSessionAutomationsSpy,
        deleteChat: async (key: string, options?: { deleteAutomations?: boolean }) => {
          if (options === undefined) await deleteChatSpy(key);
          else await deleteChatSpy(key, options);
          setSessions((prev: ChatSummary[]) => prev.filter((s) => s.key !== key));
          return { deleted: true };
        },
      };
    }),
  };
});

vi.mock("@/hooks/useTheme", async () => {
  const React = await import("react");
  return {
    ThemeProvider: ({ children }: { children: React.ReactNode }) =>
      React.createElement(React.Fragment, null, children),
    useTheme: () => ({
      theme: "light" as const,
      preference: "light" as const,
      setTheme: vi.fn(),
      toggle: toggleThemeSpy,
    }),
    useThemeValue: () => "light" as const,
  };
});

vi.mock("@/lib/bootstrap", () => ({
  BootstrapAuthRequiredError: class BootstrapAuthRequiredError extends Error {
    constructor(message = "bootstrap authentication required") {
      super(message);
      this.name = "BootstrapAuthRequiredError";
    }
  },
  fetchBootstrap: vi.fn().mockResolvedValue({
    token: "tok",
    api_token: "api-tok",
    ws_path: "/",
    expires_in: 300,
  }),
  deriveWsUrl: vi.fn(() => "ws://test"),
  consumeUrlBootstrapSecret: vi.fn(() => ""),
  loadSavedSecret: vi.fn(() => ""),
  saveSecret: vi.fn(),
  clearSavedSecret: vi.fn(),
}));

vi.mock("@/lib/nanobot-client", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@/lib/nanobot-client")>();
  class MockClient {
    onTaskNotice = () => () => {};
    status = "idle" as const;
    defaultChatId = mockDefaultChatId;
    sendSystemCommand = sendSystemCommandSpy;
    connect = connectSpy;
    onStatus = (handler: (status: ConnectionStatus) => void) => {
      statusHandlers.add(handler);
      return () => statusHandlers.delete(handler);
    };
    onRuntimeModelUpdate = () => () => {};
    onPairingChange = (handler: () => void) => {
      pairingChangeHandlers.add(handler);
      return () => pairingChangeHandlers.delete(handler);
    };
    onReady = (handler: () => void) => {
      readyHandlers.add(handler);
      return () => readyHandlers.delete(handler);
    };
    onError = () => () => {};
    onChat = () => () => {};
    onTranscript = () => () => {};
    onSessionUpdate = (handler: (
      chatId: string,
      scope?: string,
      workspaceScope?: WorkspaceScopePayload,
    ) => void) => {
      sessionUpdateHandlers.add(handler);
      return () => sessionUpdateHandlers.delete(handler);
    };
    onSidebarStateUpdate = (handler: (state: SidebarStatePayload) => void) => {
      sidebarStateUpdateHandlers.add(handler);
      return () => sidebarStateUpdateHandlers.delete(handler);
    };
    onRunStatus = (handler: (chatId: string, state: RunState) => void) => {
      runStatusHandlers.add(handler);
      return () => runStatusHandlers.delete(handler);
    };
    onRunCompletion = () => () => {};
    getRunState = () => runState(null);
    restorePendingRun = vi.fn();
    getRunStartedAt = () => null;
    getRunTurnId = () => null;
    getUnsettledRunChatIds = () => [];
    getRunGeneration = () => 0;
    hasUnsettledRun = () => false;
    canReconcileCanonicalCompletion = () => true;
    reconcileCanonicalCompletion = () => true;
    fenceCanonicalCompletedTurns = vi.fn();
    getGoalState = () => undefined;
    sendMessage = sendMessageSpy;
    newChat = vi.fn();
    newTemporaryChat = newTemporaryChatSpy;
    attach = attachSpy;
    setSidebarState = setSidebarStateSpy;
    requestMutation = requestMutationSpy;
    discardTemporaryChat = discardTemporaryChatSpy;
    close = vi.fn();
    updateUrl = updateUrlSpy;
    updateMaxFrameBytes = vi.fn();
  }

  return { ...actual, NanobotClient: MockClient };
});

import {
  BootstrapAuthRequiredError,
  deriveWsUrl,
  fetchBootstrap,
} from "@/lib/bootstrap";
import App from "@/App";
import { mockBrowserFocus } from "./browser-focus";

const defaultUseSessions = vi.mocked(useSessions).getMockImplementation()!;

describe("App layout", () => {
  let restoreBrowserFocus: (() => void) | undefined;
  beforeEach(async () => {
    await i18n.changeLanguage("en");
    mockSessions = [];
    vi.mocked(useSessions).mockImplementation(defaultUseSessions);
    clearReloadCache();
    connectSpy.mockClear();
    updateUrlSpy.mockClear();
    refreshSpy.mockReset();
    createChatSpy.mockClear();
    deleteChatSpy.mockReset();
    getSessionAutomationsSpy.mockReset().mockResolvedValue([]);
    toggleThemeSpy.mockReset();
    attachSpy.mockReset();
    setSidebarStateSpy.mockReset().mockImplementation(
      async (state: SidebarStatePayload) => state,
    );
    requestMutationSpy.mockReset();
    discardTemporaryChatSpy.mockReset();
    let temporaryChatCounter = 0;
    newTemporaryChatSpy.mockImplementation(async () => (
      `00000000-0000-4000-8000-${String(++temporaryChatCounter).padStart(12, "0")}`
    ));
    sendMessageSpy.mockReset();
    sendSystemCommandSpy.mockReset().mockResolvedValue(undefined);
    mockDefaultChatId = null;
    statusHandlers.clear();
    runStatusHandlers.clear();
    sessionUpdateHandlers.clear();
    sidebarStateUpdateHandlers.clear();
    pairingChangeHandlers.clear();
    readyHandlers.clear();
    window.history.replaceState(null, "", "/");
    sessionStorage.removeItem("nanobot.remote-instance");
    Reflect.deleteProperty(window, "nanobotHost");
    setNavigatorPlatform("Linux x86_64");
    localStorage.removeItem("nanobot-webui.sidebar");
    localStorage.removeItem("nanobot-webui.sidebar.width");
    localStorage.removeItem("nanobot-webui.sidebar.completed-runs.v1");
    localStorage.removeItem("nanobot-webui.sidebar.session-updates.v1");
    localStorage.removeItem("nanobot-webui.collapsed-pane-groups.v1");
    localStorage.removeItem("nanobot-webui.restartStartedAt");
    localStorage.removeItem("nanobot-webui.restartRoute");
    vi.mocked(fetchBootstrap).mockReset().mockResolvedValue({
      token: "tok",
      api_token: "api-tok",
      ws_path: "/",
      expires_in: 300,
    });
    vi.mocked(deriveWsUrl).mockReset().mockReturnValue("ws://test");
    mockFetchRoutes({});
  });

  afterEach(() => {
    cleanup();
    restoreBrowserFocus?.();
    restoreBrowserFocus = undefined;
    Reflect.deleteProperty(window, "nanobotHost");
    vi.useRealTimers();
    vi.unstubAllGlobals();
  });

  it.each(["skills", "apps", "channels", "automations", "settings", "chat"]) (
    "keeps the %s document skeleton while bootstrap is pending", (surface) => {
      window.history.replaceState(null, "", `/#/${surface}`);
      vi.mocked(fetchBootstrap).mockReturnValueOnce(new Promise(() => {}));
      render(<App />);
      expect(screen.getByRole("main")).toHaveAttribute("aria-busy", "true");
      expect(screen.getByRole("main")).toHaveAttribute("data-startup-surface", surface);
      expect(screen.getByRole("status")).toHaveTextContent("Loading nanobot…");
    },
  );

  it.each([false, true])("enables task controls only when bootstrap advertises support: %s", async (supported) => {
    mockSessions = [{
      key: "websocket:chat-a", channel: "websocket", chatId: "chat-a",
      createdAt: null, updatedAt: null, title: "Inspection", preview: "Inspect config",
    }];
    window.history.replaceState(null, "", "/#/chat/websocket%3Achat-a");
    vi.mocked(fetchBootstrap).mockResolvedValue({
      token: "tok", api_token: "api-tok", ws_path: "/", expires_in: 300,
      terminal: { webui: { capabilities: supported ? ["webui.core.v1", "webui.subagents.v1"] : ["webui.core.v1"] } },
    });
    mockFetchRoutes({
      "/api/sessions/websocket%3Achat-a/subagents": { tasks: [{
        task_id: "task-1", label: "Config check", task_description: "Inspect configuration",
        state: "running", phase: "awaiting_model", elapsed_seconds: 2, iteration: 1,
        tool_events: [], usage: null, receipts: {}, result: null, partial: false,
        stop_reason: null, error: null, origin_turn_id: null, origin_message_id: null,
        created_at: 100, completed_at: null,
      }] },
    });
    render(<App />);
    // Await the lazy module itself; cold Vite transformation is not the task
    // capability contract exercised by the timed DOM assertions below.
    await act(async () => { await import("@/components/thread/ThreadShell"); });
    await screen.findByRole("textbox", {}, { timeout: 5_000 });
    if (supported) {
      const trigger = await screen.findByRole("button", { name: "Subtasks · Running: 1" });
      expect(trigger).toHaveAttribute("aria-expanded", "false");
      await userEvent.setup().click(trigger);
      expect(await screen.findByRole("button", { name: /Config check Running/ })).toBeVisible();
    } else expect(screen.queryByRole("button", { name: /Subtasks/ })).not.toBeInTheDocument();
    const reads = vi.mocked(fetch).mock.calls.filter(([url]) => String(url).endsWith("/subagents"));
    expect(reads).toHaveLength(supported ? 1 : 0);
    expect(requestMutationSpy).not.toHaveBeenCalled();
  });

  it("shows the auth form without an invalid-password error on first load", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValueOnce(
      new Error("bootstrap failed: HTTP 401"),
    );

    render(<App />);

    expect(await screen.findByRole("heading", { level: 1, name: "Connect to nanobot" }))
      .toBeInTheDocument();
    const password = screen.getByLabelText("WebUI password");
    expect(password).not.toHaveAttribute("aria-describedby");
    expect(password).toHaveAttribute(
      "autocomplete",
      "current-password",
    );
    expect(password).not.toHaveAttribute("placeholder");
    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
    expect(connectSpy).not.toHaveBeenCalled();
  });

  it("switches language before connecting while preserving the password draft", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValueOnce(
      new Error("bootstrap failed: HTTP 401"),
    );
    const user = userEvent.setup();

    render(<App />);

    await user.type(await screen.findByLabelText("WebUI password"), "draft-password");
    await user.tab({ shift: true });
    expect(screen.getByRole("combobox", { name: "Change language" })).toHaveFocus();
    await user.keyboard("{Enter}");
    await screen.findByRole("listbox");
    await user.keyboard("{ArrowDown}{Enter}");

    expect(await screen.findByRole("heading", { name: "连接到 nanobot" }))
      .toBeInTheDocument();
    expect(screen.getByLabelText("WebUI 密码")).toHaveValue("draft-password");
    expect(screen.getByRole("button", { name: "连接" })).toBeEnabled();
    expect(document.documentElement.lang).toBe("zh-CN");
    expect(localStorage.getItem("nanobot.locale")).toBe("zh-CN");
    expect(fetchBootstrap).toHaveBeenCalledTimes(1);
    expect(connectSpy).not.toHaveBeenCalled();
  });

  it("reveals password setup help with the keyboard without submitting the form", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValueOnce(
      new Error("bootstrap failed: HTTP 401"),
    );
    const user = userEvent.setup();

    render(<App />);

    const password = await screen.findByLabelText("WebUI password");
    await user.type(password, "draft-password");
    await user.tab();
    await user.tab();
    await user.tab();
    const help = screen.getByRole("button", { name: "Where can I find the password?" });
    expect(help).toHaveFocus();
    expect(help).toHaveAttribute("aria-expanded", "false");
    const content = document.getElementById(help.getAttribute("aria-controls")!);
    expect(content).toHaveAttribute("aria-hidden", "true");

    await user.keyboard("{Enter}");

    expect(help).toHaveAttribute("aria-expanded", "true");
    expect(content).not.toHaveAttribute("aria-hidden");
    expect(content).toHaveTextContent("~/.nanobot/config.json");
    expect(content).toHaveTextContent("channels.websocket.tokenIssueSecret");
    expect(content).toHaveTextContent("If that value is empty, use channels.websocket.token.");

    await user.keyboard(" ");

    expect(help).toHaveAttribute("aria-expanded", "false");
    expect(password).toHaveValue("draft-password");
    expect(fetchBootstrap).toHaveBeenCalledTimes(1);
  });

  it("toggles password visibility without changing the password", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValueOnce(
      new Error("bootstrap failed: HTTP 401"),
    );
    const user = userEvent.setup();

    render(<App />);

    const password = await screen.findByLabelText("WebUI password");
    await user.type(password, "correct horse battery staple");
    expect(password).toHaveAttribute("type", "password");

    await user.click(screen.getByRole("button", { name: "Show password" }));

    expect(password).toHaveAttribute("type", "text");
    expect(password).toHaveValue("correct horse battery staple");
    const hidePassword = screen.getByRole("button", { name: "Hide password" });
    expect(hidePassword).toHaveFocus();

    await user.click(hidePassword);

    expect(password).toHaveAttribute("type", "password");
    expect(password).toHaveValue("correct horse battery staple");
    expect(screen.getByRole("button", { name: "Show password" })).toHaveFocus();
  });

  it("explains and focuses an empty auth password", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValue(
      new Error("bootstrap failed: HTTP 401"),
    );

    render(<App />);

    const password = await screen.findByLabelText("WebUI password");
    const connect = screen.getByRole("button", { name: "Connect" });
    expect(connect).toBeEnabled();
    fireEvent.click(connect);

    expect(await screen.findByRole("alert")).toHaveTextContent(
      "Enter password",
    );
    expect(password).toHaveAttribute("placeholder", "Enter password");
    expect(password).toHaveAttribute("aria-invalid", "true");
    expect(password).toHaveAttribute(
      "aria-describedby",
      "webui-auth-error",
    );
    expect(password).toHaveFocus();
    fireEvent.change(password, { target: { value: "   " } });
    fireEvent.click(connect);
    expect(password).toHaveValue("");
    expect(password).toHaveAttribute("placeholder", "Enter password");
    expect(fetchBootstrap).toHaveBeenCalledTimes(1);
  });

  it("shows the auth form when bootstrap does not issue an API token", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValueOnce(
      new BootstrapAuthRequiredError(
        "bootstrap authentication required: missing api_token",
      ),
    );

    render(<App />);

    expect(await screen.findByRole("heading", { level: 1, name: "Connect to nanobot" }))
      .toBeInTheDocument();
    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
    expect(connectSpy).not.toHaveBeenCalled();
  });

  it("shows an invalid-password error after a submitted password is rejected", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValue(
      new Error("bootstrap failed: HTTP 401"),
    );

    render(<App />);

    const password = await screen.findByLabelText("WebUI password");
    fireEvent.change(password, { target: { value: "wrong-password" } });
    fireEvent.click(screen.getByRole("button", { name: "Connect" }));

    const retryPassword = await screen.findByLabelText("WebUI password");
    expect(await screen.findByRole("alert")).toHaveTextContent(
      "Incorrect password",
    );
    expect(retryPassword).toHaveAttribute("placeholder", "Incorrect password");
    expect(retryPassword).toHaveValue("");
    expect(retryPassword).toHaveAttribute("aria-invalid", "true");
    expect(retryPassword).toHaveFocus();
    expect(fetchBootstrap).toHaveBeenLastCalledWith("", "wrong-password");
    expect(connectSpy).not.toHaveBeenCalled();
    fireEvent.change(retryPassword, { target: { value: "retry-password" } });
    expect(retryPassword).not.toHaveAttribute("placeholder");
    expect(retryPassword).not.toHaveAttribute("aria-invalid");
    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
  });

  it("clears auth feedback after three seconds without moving focus", async () => {
    vi.mocked(fetchBootstrap).mockRejectedValue(
      new Error("bootstrap failed: HTTP 401"),
    );
    render(<App />);
    const password = await screen.findByLabelText("WebUI password");
    vi.useFakeTimers();

    fireEvent.click(screen.getByRole("button", { name: "Connect" }));
    expect(password).toHaveAttribute("placeholder", "Enter password");
    act(() => vi.advanceTimersByTime(3_000));
    expect(password).not.toHaveAttribute("placeholder");
    expect(password).toHaveFocus();

    await act(async () => {
      fireEvent.change(password, { target: { value: "wrong-password" } });
      fireEvent.click(screen.getByRole("button", { name: "Connect" }));
    });
    const retryPassword = screen.getByLabelText("WebUI password");
    expect(retryPassword).toHaveAttribute("placeholder", "Incorrect password");
    act(() => vi.advanceTimersByTime(2_999));
    expect(retryPassword).toHaveAttribute("placeholder", "Incorrect password");
    act(() => vi.advanceTimersByTime(1));
    expect(retryPassword).not.toHaveAttribute("placeholder");
    expect(retryPassword).not.toHaveAttribute("aria-invalid");
    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
    expect(retryPassword).toHaveFocus();
  });

  it("keeps sidebar layout out of the main thread width contract", async () => {
    const { container } = render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());

    const main = container.querySelector("main");
    expect(main).toBeInTheDocument();
    expect(main).not.toHaveAttribute("style");
    expect(screen.getByTestId("sidebar-brand-row")).toHaveClass("pt-3");
    expect(screen.getByTestId("sidebar-brand-mark")).not.toHaveClass("mt-5");
    expect(screen.getByRole("separator", { name: "Resize sidebar" })).toHaveAttribute("aria-valuenow", "272");

    const asideClassNames = Array.from(container.querySelectorAll("aside")).map(
      (el) => el.className,
    );
    expect(asideClassNames.some((cls) => cls.includes("lg:block"))).toBe(true);
  });

  it("uses one main landmark and a page heading in desktop settings", async () => {
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });
    const { container } = render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Settings" }));

    await act(async () => {
      await import("@/components/settings/SettingsView");
    });

    expect(
      screen.getByRole("navigation", { name: "Settings sections" }),
    ).toBeInTheDocument();
    const backButton = screen.getByRole("button", { name: "Back to chat" });
    expect(backButton.closest("aside")).toHaveClass("pt-4", "lg:pt-4");
    expect(backButton).not.toHaveClass("-ml-1");
    expect(container.querySelectorAll("main")).toHaveLength(1);
    expect(screen.getByRole("navigation", { name: "Settings sections" })).toBeInTheDocument();
  });

  it("opens the full Models settings directly from the first-run prompt", async () => {
    const user = userEvent.setup();
    const base = baseSettingsPayload();
    mockFetchRoutes({
      "/api/settings": {
        ...base,
        agent: {
          ...base.agent,
          model: "",
          resolved_provider: "",
          has_api_key: false,
          model_preset: "",
        },
        model_presets: [],
        model_call_order: [],
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    await user.click(await screen.findByRole("button", { name: "Choose model" }));

    expect(
      await screen.findByRole("navigation", { name: "Settings sections" }),
    ).toBeInTheDocument();
    expect(screen.getByRole("heading", { name: "Model presets" })).toBeInTheDocument();
    await user.click(screen.getByRole("button", { name: "Manage providers" }));
    expect(screen.getByRole("dialog", { name: "Manage providers" })).toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Add provider" })).toBeInTheDocument();
    expect(screen.queryByRole("dialog", { name: "Choose model" })).not.toBeInTheDocument();
  });

  it("places Automations after Skills in the main sidebar", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const appsButton = within(sidebar).getByRole("button", { name: "Apps" });
    const skillsButton = within(sidebar).getByRole("button", { name: "Skills" });
    const automationsButton = within(sidebar).getByRole("button", { name: "Automations" });

    expect(appsButton.compareDocumentPosition(skillsButton) & Node.DOCUMENT_POSITION_FOLLOWING)
      .toBeTruthy();
    expect(
      skillsButton.compareDocumentPosition(automationsButton) &
        Node.DOCUMENT_POSITION_FOLLOWING,
    ).toBeTruthy();
  });

  it("opens Channels below Automations and supports its keyboard shortcut", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/nanobot-features": { features: [], enabled_count: 0 },
    });
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const channels = within(sidebar).getByRole("button", { name: "Channels" });
    expect(within(sidebar).getByRole("button", { name: "Automations" })
      .compareDocumentPosition(channels) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
    fireEvent.click(channels);
    expect(await screen.findByRole("heading", { name: "Channels" })).toBeVisible();
    expect(window.location.hash).toBe("#/channels");
    expect(channels).toHaveAttribute("aria-current", "page");
    expect(document.title).toBe("Channels");
    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    await waitFor(() => expect(window.location.hash).toBe("#/new"));
    fireEvent.keyDown(window, { key: "$", code: "Digit4", ctrlKey: true, shiftKey: true });
    expect(await screen.findByRole("heading", { name: "Channels" })).toBeVisible();
    expect(window.location.hash).toBe("#/channels");
  });

  it("opens management in the main content area while keeping the standalone deep link", async () => {
    requestMutationSpy.mockResolvedValue({ hosts: [], files: [], incomplete: false });
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/remote-instances": { available: true, profiles: [] },
    });
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const originalHash = window.location.hash;
    const originalTitle = document.title;
    expect(within(sidebar).queryByRole("button", { name: "Remote connections" })).not.toBeInTheDocument();
    fireEvent.pointerDown(await within(sidebar).findByRole("button", { name: "Switch host" }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Manage connections" }));
    expect(await screen.findByRole("heading", { name: "Remote connections" })).toBeVisible();
    expect(screen.getByRole("main")).toContainElement(screen.getByRole("region", { name: "Remote connections" }));
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    expect(sidebar).toBeVisible();
    fireEvent.click(await screen.findByRole("button", { name: "Connect to remote nanobot" }));
    fireEvent.pointerDown(screen.getByRole("button", { name: "Other ways" }), { button: 0, ctrlKey: false });
    fireEvent.click(screen.getByRole("menuitem", { name: "SSH connection" }));
    const host = await screen.findByRole("textbox", { name: "SSH address" });
    expect(screen.getByRole("dialog", { name: "Add connection" })).toContainElement(host);
    expect(window.location.hash).toBe(originalHash);
    expect(document.title).toBe(originalTitle);
    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
    fireEvent.click(screen.getByRole("button", { name: "Back" }));
    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    expect(window.location.hash).toBe("#/new");
    expect(screen.queryByRole("textbox", { name: "SSH address" })).not.toBeInTheDocument();
    act(() => {
      window.history.replaceState(null, "", "#/remote");
      window.dispatchEvent(new PopStateEvent("popstate"));
    });
    expect(await screen.findByRole("button", { name: "Connect to remote nanobot" })).toBeVisible();
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    expect(within(sidebar).queryByRole("button", { name: "Remote connections" })).not.toBeInTheDocument();
  });

  it("lets sidebar navigation leave the management page without a second dismissal", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/remote-instances": { available: true, profiles: [] },
    });
    render(<App />);
    const sidebar = await screen.findByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.pointerDown(await within(sidebar).findByRole("button", { name: "Switch host" }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Manage connections" }));
    expect(await screen.findByRole("region", { name: "Remote connections" })).toBeVisible();
    fireEvent.click(within(sidebar).getByRole("button", { name: "Apps" }));
    expect(await screen.findByRole("heading", { name: "Apps" })).toBeVisible();
    expect(screen.queryByRole("region", { name: "Remote connections" })).not.toBeInTheDocument();
    expect(window.location.hash).toBe("#/apps");
  });

  it("closes the mobile sidebar when managing connections from its host menu", async () => {
    const user = userEvent.setup();
    requestMutationSpy.mockResolvedValue({ hosts: [], files: [], incomplete: false });
    vi.stubGlobal("matchMedia", vi.fn().mockImplementation((query: string) => ({
      matches: !query.includes("1024px"), media: query, onchange: null,
      addListener: vi.fn(), removeListener: vi.fn(), addEventListener: vi.fn(),
      removeEventListener: vi.fn(), dispatchEvent: vi.fn(),
    })));
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/remote-instances": { available: true, profiles: [] },
    });
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    await user.click(await screen.findByRole("button", { name: "Toggle sidebar" }));
    const sheet = await screen.findByRole("dialog");
    fireEvent.pointerDown(await within(sheet).findByRole("button", { name: "Switch host" }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Manage connections" }));
    await waitFor(() => expect(sheet).not.toBeInTheDocument());
    expect(screen.getByRole("main")).toContainElement(screen.getByRole("region", { name: "Remote connections" }));
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    expect(await screen.findByRole("heading", { name: "Remote connections" })).toBeVisible();
    expect(window.location.hash).not.toBe("#/remote");
    expect(screen.queryByRole("button", { name: "Remote connections" })).not.toBeInTheDocument();
    await user.click(screen.getByRole("button", { name: "Connect to remote nanobot" }));
    expect(await screen.findByRole("dialog", { name: "Connect to remote nanobot" })).toBeVisible();
  });

  it("releases the mobile sidebar modal when switching to a server", async () => {
    const user = userEvent.setup();
    vi.stubGlobal("matchMedia", vi.fn().mockImplementation((query: string) => ({
      matches: !query.includes("1024px"), media: query, onchange: null,
      addListener: vi.fn(), removeListener: vi.fn(), addEventListener: vi.fn(),
      removeEventListener: vi.fn(), dispatchEvent: vi.fn(),
    })));
    const profile = { id: "3b968d52-081d-4898-9970-ff0a1fc93817", name: "Team server",
      host: "team", port: null, ssh_config: "", identity_file: "",
      config_path: "~/.nanobot/config.json", runtime_user: "", connected: false };
    requestMutationSpy.mockResolvedValue({ ...profile, hostname: "team-host", gateway_id: "remote-gateway",
      url: "http://127.0.0.1:23456/#/?bootstrapSecret=test-only" });
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/remote-instances": { available: true, profiles: [profile] },
    });
    render(<App />);
    await user.click(await screen.findByRole("button", { name: "Toggle sidebar" }));
    const sheet = await screen.findByRole("dialog");
    await user.click(await within(sheet).findByRole("button", { name: "Switch host" }));
    await user.click(await screen.findByRole("menuitem", { name: "Team server team" }));
    const frame = await screen.findByTitle("nanobot on Team server");
    fireEvent.load(frame);
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
    await waitFor(() => expect(document.body.style.pointerEvents).not.toBe("none"));
    expect(frame).toBeVisible();
  });

  it("opens a remote setup deep link after reloading without opening Settings", async () => {
    requestMutationSpy.mockResolvedValue({ hosts: [], files: [], incomplete: false });
    window.history.replaceState(null, "", "#/remote");
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/remote-instances": { available: true, profiles: [] },
    });
    render(<App />);
    expect(await screen.findByRole("button", { name: "Connect to remote nanobot" })).toBeVisible();
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    expect(screen.getByRole("navigation", { name: "Sidebar navigation" })).toBeVisible();
    expect(screen.queryByRole("navigation", { name: "Settings sections" })).not.toBeInTheDocument();
    expect(window.location.hash).toBe("#/remote");
  });

  it("highlights the blank new-topic destination immediately", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const newTopicButton = within(sidebar).getByRole("button", { name: "New topic" });

    expect(newTopicButton).toHaveAttribute("aria-current", "page");
    expect(newTopicButton).toHaveClass("transition-[width,padding,color,background-color]");
    expect(newTopicButton).toBeEnabled();
  });

  it("keeps a just-created topic route while the session list catches up", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const firstMessage = "keep this first turn visible";
    fireEvent.change(screen.getByRole("textbox", { name: "Message input" }), {
      target: { value: firstMessage },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    await waitFor(() => expect(createChatSpy).toHaveBeenCalledTimes(1));
    await waitFor(() =>
      expect(window.location.hash).toBe(
        `#/chat/${encodeURIComponent("websocket:chat-1")}`,
      ),
    );
    expect(await screen.findByText(firstMessage)).toBeInTheDocument();
  });

  it("creates a new temporary chat from the hero each time", async () => {
    const { unmount } = render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(sidebar).queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();
    const firstToggle = screen.getByRole("button", { name: "Temporary chat" });
    expect(firstToggle).toHaveAttribute("aria-pressed", "false");
    fireEvent.click(firstToggle);
    expect(firstToggle).toHaveAttribute("aria-pressed", "true");
    expect(window.location.hash).toBe("");

    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "first private message" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    await waitFor(() => expect(window.location.hash).toMatch(/^#\/temporary\/[0-9a-f-]+$/));
    const firstHash = window.location.hash;
    expect(firstHash).toMatch(/^#\/temporary\/[0-9a-f-]+$/);
    expect(screen.queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();
    expect(createChatSpy).not.toHaveBeenCalled();

    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    expect(discardTemporaryChatSpy).not.toHaveBeenCalled();
    const secondToggle = screen.getByRole("button", { name: "Temporary chat" });
    expect(secondToggle).toHaveAttribute("aria-pressed", "false");

    fireEvent.click(secondToggle);
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "second private message" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(window.location.hash).toMatch(/^#\/temporary\/[0-9a-f-]+$/));
    const secondHash = window.location.hash;
    expect(secondHash).toMatch(/^#\/temporary\/[0-9a-f-]+$/);
    expect(secondHash).not.toBe(firstHash);
    expect(screen.queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();
    expect(discardTemporaryChatSpy).not.toHaveBeenCalled();

    expect(within(sidebar).getByText("Temporary chats")).toBeInTheDocument();
    expect(within(sidebar).getByRole("button", {
      name: "first private message",
    })).toBeInTheDocument();
    expect(within(sidebar).getByRole("button", {
      name: "second private message",
    })).toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", {
      name: "first private message",
    }));
    await waitFor(() => expect(window.location.hash).toBe(firstHash));
    expect(within(screen.getByTestId("thread-header")).getByText(
      "first private message",
    )).toBeInTheDocument();
    await waitFor(() => expect(document.title).toBe("first private message"));
    expect(screen.queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", {
      name: "Close temporary chat: first private message",
    }));
    await waitFor(() => expect(window.location.hash).toBe(secondHash));
    expect(within(sidebar).queryByRole("button", {
      name: "first private message",
    })).not.toBeInTheDocument();
    expect(within(sidebar).getByRole("button", {
      name: "second private message",
    })).toBeInTheDocument();
    expect(discardTemporaryChatSpy).toHaveBeenCalledTimes(1);

    unmount();
    await waitFor(() => expect(discardTemporaryChatSpy).toHaveBeenCalledTimes(2));
    const discardedChatIds = discardTemporaryChatSpy.mock.calls.map(([chatId]) => chatId);
    expect(new Set(discardedChatIds).size).toBe(2);
    expect(discardedChatIds).toEqual([
      "00000000-0000-4000-8000-000000000001",
      "00000000-0000-4000-8000-000000000002",
    ]);
  });

  it("shows the temporary-chat control only on the new-topic hero", async () => {
    mockSessions = [{
      key: "websocket:existing-chat",
      channel: "websocket",
      chatId: "existing-chat",
      createdAt: "2026-08-06T10:00:00Z",
      updatedAt: "2026-08-06T10:00:00Z",
      preview: "Existing topic",
    }];
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const heroHeader = screen.getByTestId("thread-header");
    const heroTemporaryToggle = within(heroHeader).getByRole("button", {
      name: "Temporary chat",
    });
    const themeToggle = within(heroHeader).getByRole("button", {
      name: "Toggle theme from header",
    });
    expect(within(sidebar).queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();
    expect(within(screen.getByTestId("thread-composer-motion")).queryByRole("button", {
      name: "Temporary chat",
    })).not.toBeInTheDocument();
    expect(heroTemporaryToggle.compareDocumentPosition(themeToggle)
      & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();

    const user = userEvent.setup();
    await user.hover(heroTemporaryToggle);
    const temporaryTooltip = await screen.findByRole("tooltip");
    expect(temporaryTooltip).toHaveTextContent("Temporary chat");
    expect(temporaryTooltip).toHaveTextContent("Not saved to history or memory");
    expect(within(temporaryTooltip).getByText(
      "Ends on reload, close, or disconnection.",
    )).toHaveClass("font-medium");
    await user.unhover(heroTemporaryToggle);

    fireEvent.click(within(sidebar).getByText("Existing topic"));
    expect(window.location.hash).toBe("#/chat/websocket%3Aexisting-chat");
    expect(screen.queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    const temporaryToggle = screen.getByRole("button", { name: "Temporary chat" });
    expect(temporaryToggle).toHaveClass("h-8", "w-8", "rounded-control");
    expect(within(temporaryToggle).queryByText("Temporary chat")).not.toBeInTheDocument();
    fireEvent.click(temporaryToggle);
    expect(temporaryToggle).toHaveAttribute("aria-pressed", "true");
    expect(temporaryToggle).toHaveClass("icon-action");
    expect(within(temporaryToggle).getByTestId("temporary-chat-icon")).toHaveClass(
      "motion-safe:duration-150",
      "text-[var(--temporary-control-active)]",
    );
    expect(screen.queryByRole("tooltip")).not.toBeInTheDocument();
    expect(screen.queryByTestId("temporary-chat-outline")).not.toBeInTheDocument();
    fireEvent.click(temporaryToggle);
    expect(temporaryToggle).toHaveAttribute("aria-pressed", "false");
    expect(within(temporaryToggle).getByTestId("temporary-chat-icon")).toHaveClass(
      "motion-safe:duration-75",
      "text-current",
    );
    fireEvent.click(temporaryToggle);
    expect(window.location.hash).toBe("#/new");
    expect(temporaryToggle).toHaveAttribute("aria-pressed", "true");

    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "start temporary chat" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(window.location.hash).toMatch(/^#\/temporary\/[0-9a-f-]+$/));

    expect(screen.queryByText("Not saved")).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Clear chat" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Temporary chat" })).not.toBeInTheDocument();
  });

  it("allows leaving a page with temporary chats without blocking", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.click(screen.getByRole("button", { name: "Temporary chat" }));
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "do not lose this" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(window.location.hash).toMatch(/^#\/temporary\/[0-9a-f-]+$/));

    const beforeUnload = new Event("beforeunload", { cancelable: true });
    act(() => window.dispatchEvent(beforeUnload));
    expect(beforeUnload.defaultPrevented).toBe(false);
  });

  it("ends temporary chats quietly after a connection interruption", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => {
      statusHandlers.forEach((handler) => handler("open"));
    });
    fireEvent.click(screen.getByRole("button", { name: "Temporary chat" }));
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "connection-sensitive message" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(window.location.hash).toMatch(/^#\/temporary\/[0-9a-f-]+$/));

    act(() => {
      statusHandlers.forEach((handler) => handler("reconnecting"));
    });

    await waitFor(() => expect(window.location.hash).toBe("#/new"));
    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
    expect(screen.queryByText("connection-sensitive message")).not.toBeInTheDocument();
  });

  it("keeps the context-menu project through navigation and first-message creation", async () => {
    const projectScope = {
      project_path: "/tmp/selected-project",
      project_name: "selected-project",
      access_mode: "full" as const,
      restrict_to_workspace: false,
    };
    mockSessions = [{
      key: "websocket:existing-chat",
      channel: "websocket",
      chatId: "existing-chat",
      createdAt: null,
      updatedAt: null,
      preview: "Existing topic",
      workspaceScope: projectScope,
    }];
    mockFetchRoutes({
      "/api/workspaces": {
        schema_version: 1,
        default_access_mode: "full",
        default_scope: { ...projectScope, project_path: "/tmp/workspace", project_name: "workspace" },
        controls: { can_change_project: true },
      },
    });
    window.history.replaceState(null, "", "/#/chat/websocket%3Aexisting-chat");
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    await screen.findByRole("button", { name: "Workspace access mode: Full Access" });
    const projectSection = screen.getByRole("region", { name: "selected-project" });
    fireEvent.contextMenu(within(projectSection).getByRole("button", { name: "selected-project" }));
    await userEvent.setup().click(await screen.findByRole("menuitem", { name: "New topic" }));
    await waitFor(() => expect(window.location.hash).toBe("#/new"));
    expect(await screen.findByRole("button", { name: "Switch directory" })).toHaveTextContent("selected-project");
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "project topic" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(createChatSpy).toHaveBeenCalledWith(projectScope));
  });

  it("uses the restricted default scope without offering project selection", async () => {
    mockFetchRoutes({
      "/api/workspaces": {
        schema_version: 1,
        default_access_mode: "full",
        default_scope: {
          project_path: "/tmp/workspace",
          project_name: "workspace",
          access_mode: "full",
          restrict_to_workspace: false,
        },
        controls: { can_change_project: true },
      },
    });
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    expect(await screen.findByRole("button", { name: "Switch directory" })).toBeInTheDocument();
    act(() => {
      sessionUpdateHandlers.forEach((handler) => handler("selected-chat", "metadata", {
        project_path: "/tmp/selected-project",
        project_name: "selected-project",
        access_mode: "full",
        restrict_to_workspace: false,
      }));
    });
    fireEvent.click(screen.getByRole("button", { name: "Temporary chat" }));

    expect(screen.queryByRole("button", { name: "Switch directory" })).not.toBeInTheDocument();
    expect(screen.queryByText("Full Access")).not.toBeInTheDocument();
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "temporary project check" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(sendMessageSpy).toHaveBeenCalled());
    const options = sendMessageSpy.mock.calls.at(-1)?.[3];
    expect(options?.workspaceScope).toMatchObject({
      project_path: "/tmp/workspace",
      access_mode: "restricted",
      restrict_to_workspace: true,
    });
  });

  it("preserves the first message when the gateway rejects a project", async () => {
    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
    const projectPath = "C:\\missing-project";
    const directory = (path: string) => ({
      path, parent: null, entries: [], partial: false,
      truncated: false, host: "test-host", platform: "Windows",
    });
    const directoryUrl = (path: string) => `/api/workspaces/directories?${new URLSearchParams({ path, q: "", hidden: "0", partial: "1" })}`;
    requestMutationSpy.mockResolvedValue({ path: projectPath, name: "missing-project" });
    createChatSpy.mockRejectedValueOnce(
      new Error("workspace_scope_rejected:project_path must be an existing directory"),
    );
    mockFetchRoutes({
      "/api/workspaces": {
        schema_version: 1,
        default_access_mode: "default",
        default_scope: {
          project_path: "C:\\workspace",
          project_name: "workspace",
          access_mode: "restricted",
          restrict_to_workspace: true,
        },
        controls: { can_change_project: true, can_browse_directories: true, can_resolve_project: true },
      },
      [directoryUrl("C:\\workspace")]: directory("C:\\workspace"),
      [directoryUrl("C:\\workspace\\")]: directory("C:\\workspace"),
      [directoryUrl(projectPath)]: directory(projectPath),
      [directoryUrl(`${projectPath}\\`)]: directory(projectPath),
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.click(await screen.findByRole("button", { name: "Switch directory" }));
    fireEvent.click(screen.getByRole("button", { name: /^Edit path:/ }));
    fireEvent.change(await screen.findByRole("combobox"), {
      target: { value: projectPath },
    });
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    fireEvent.click(screen.getByRole("button", { name: "Confirm" }));
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());

    const message = screen.getByLabelText("Message input");
    fireEvent.change(message, { target: { value: "keep this first message" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    await waitFor(() => expect(createChatSpy).toHaveBeenCalledTimes(1));
    expect(message).toHaveValue("keep this first message");
    const projectButton = screen.getByRole("button", { name: "Switch directory" });
    await waitFor(() => expect(projectButton).toHaveFocus());
    expect(screen.getByRole("alert")).toHaveTextContent(
      "The gateway rejected this project or access mode. Choose an existing project or a different access mode, then try again.",
    );
    fireEvent.click(projectButton);
    fireEvent.click(screen.getByRole("button", { name: /^Edit path:/ }));
    const pathInput = await screen.findByRole("combobox");
    expect(pathInput).toHaveValue(`${projectPath}\\`);
    expect(pathInput).toHaveAttribute("aria-invalid", "true");
    expect(pathInput).toHaveFocus();
    expect(screen.getByRole("alert")).toHaveTextContent(
      "The gateway rejected this project or access mode. Choose an existing project or a different access mode, then try again.",
    );
    expect(window.location.hash).toBe("");
    consoleError.mockRestore();
  });

  it("restores the standalone Channels page from a legacy restart route", async () => {
    localStorage.setItem("nanobot-webui.restartStartedAt", String(Date.now()));
    localStorage.setItem("nanobot-webui.restartRoute", "#/settings?section=channels");
    window.history.replaceState(null, "", "/#/new");
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/nanobot-features": {
        features: [{
          name: "websocket",
          display_name: "Websocket",
          type: "channel",
          enabled: true,
          installed: true,
          ready: true,
          status: "enabled",
          install_supported: true,
          requires_restart: true,
        }],
        enabled_count: 1,
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    expect(
      await screen.findByRole("heading", { name: "Channels" }),
    ).toBeInTheDocument();
    expect(within(screen.getByRole("navigation", { name: "Sidebar navigation" })).getByRole("button", { name: "Channels" })).toHaveAttribute("aria-current", "page");
    expect(window.location.hash).toBe("#/settings?section=channels");
  });

  it.each(["before disconnect", "after disconnect"])("finishes a requested restart when another tab clears its marker %s", async (clearWhen) => {
    mockDefaultChatId = "restart-fixture";
    window.history.replaceState(null, "", "/#/settings?section=runtime");
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });
    render(<App />);
    fireEvent.click(await screen.findByRole("button", { name: "Restart" }));
    expect(sendSystemCommandSpy).toHaveBeenCalledWith("restart-fixture", "/restart");
    expect(screen.getByRole("button", { name: "Restarting..." })).toBeDisabled();
    act(() => {
      if (clearWhen === "before disconnect") localStorage.removeItem("nanobot-webui.restartStartedAt");
      for (const handler of statusHandlers) handler("reconnecting");
      localStorage.removeItem("nanobot-webui.restartStartedAt");
      for (const handler of statusHandlers) handler("open");
    });
    await waitFor(() => expect(screen.getByRole("button", { name: "Restart" })).toBeEnabled());
    expect(createChatSpy).not.toHaveBeenCalled();
  });

  it("refreshes settings after the browser reconnects from a restart", async () => {
    let restartCompleted = false;
    let refreshedSettingsRequests = 0;
    let releaseRefreshedSettings!: () => void;
    const refreshedSettingsReady = new Promise<void>((resolve) => {
      releaseRefreshedSettings = resolve;
    });
    const pendingSettings = {
      ...baseSettingsPayload(),
      requires_restart: true,
      restart_required_sections: ["runtime"],
    };
    const refreshedSettings = {
      ...baseSettingsPayload(),
      requires_restart: false,
      restart_required_sections: [],
    };
    localStorage.setItem("nanobot-webui.restartStartedAt", String(Date.now() - 2_000));
    window.history.replaceState(null, "", "/#/settings?section=runtime");
    mockFetchRoutes({
      "/api/settings": () => {
        if (!restartCompleted) return pendingSettings;
        refreshedSettingsRequests += 1;
        if (refreshedSettingsRequests === 1) throw new Error("gateway is still starting");
        return refreshedSettingsReady.then(() => refreshedSettings);
      },
    });

    render(<App />);

    await waitFor(() => {
      expect(screen.getAllByText("Saved. Restart to apply changes.").length).toBeGreaterThan(0);
    }, { timeout: 10_000 });

    restartCompleted = true;
    act(() => {
      for (const handler of statusHandlers) handler("reconnecting");
      for (const handler of statusHandlers) handler("open");
    });

    await waitFor(() => expect(refreshedSettingsRequests).toBeGreaterThan(1));
    await act(async () => {
      releaseRefreshedSettings();
      await refreshedSettingsReady;
    });
    fireEvent.click(screen.getByRole("button", { name: "Back to chat" }));
    await waitFor(() => expect(window.location.hash).toBe("#/new"));
    expect(await screen.findByText(HERO_GREETING_PATTERN, {}, { timeout: 10_000 })).toBeInTheDocument();
  }, 30_000);

  it("opens Skills from the main sidebar", async () => {
    const longSkillDescription = [
      "Work with GitHub repositories, issues, pull requests, releases, workflows,",
      "and code search through the GitHub CLI.",
      "Use this skill for repository maintenance, review automation, release preparation,",
      "and other GitHub workflows that need authenticated command-line access.",
    ].join(" ");
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/cli-apps": { apps: [], installed_count: 0, catalog_updated_at: "2026-04-18" },
      "/api/settings/mcp-presets": { presets: [], installed_count: 0 },
      "/api/webui/skills": {
        skills: [
          {
            name: "cron",
            description: "Schedule reminders.",
            source: "builtin",
            enabled: true,
            deletable: false,
            available: true,
          },
          {
            name: "github",
            description: "Work with GitHub.",
            source: "builtin",
            enabled: true,
            deletable: false,
            available: false,
            unavailable_reason: "CLI: gh",
          },
          {
            name: "custom-skill",
            description: "A workspace skill.",
            source: "workspace",
            enabled: true,
            deletable: true,
            available: true,
          },
        ],
      },
      "/api/webui/skills/github": {
        name: "github",
        description: longSkillDescription,
        source: "builtin",
        enabled: true,
        deletable: false,
        available: false,
        unavailable_reason: "CLI: gh",
        requirements: {
          bins: ["gh"],
          env: [],
          missing_bins: ["gh"],
          missing_env: [],
        },
        install_options: [{
          id: "brew",
          kind: "brew",
          label: "Install GitHub CLI (brew)",
          command: "brew install gh",
        }],
        raw_markdown: "---\nname: github\n---\nUse GitHub CLI.",
      },
    });
    requestMutationSpy.mockResolvedValueOnce({
      skills: [
        {
          name: "cron",
          description: "Schedule reminders.",
          source: "builtin",
          enabled: true,
          deletable: false,
          available: true,
        },
        {
          name: "github",
          description: "Work with GitHub.",
          source: "builtin",
          enabled: false,
          deletable: false,
          available: false,
          unavailable_reason: "CLI: gh",
        },
        {
          name: "custom-skill",
          description: "A workspace skill.",
          source: "workspace",
          enabled: true,
          deletable: true,
          available: true,
        },
      ],
      last_action: { name: "github", enabled: false, deleted: false },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const skillsButton = within(sidebar).getByRole("button", { name: "Skills" });

    fireEvent.click(skillsButton);

    expect(await screen.findByRole("heading", { name: "Skills" })).toBeInTheDocument();
    expect(screen.getByRole("textbox", { name: "Search installed skills" })).toBeInTheDocument();
    expect(screen.getByRole("heading", { name: "Custom" })).toBeInTheDocument();
    expect(screen.getByRole("heading", { name: "Built-in" })).toBeInTheDocument();
    expect(screen.getByText("cron")).toBeInTheDocument();
    expect(screen.getByText("github")).toBeInTheDocument();
    expect(screen.getByText("Needs setup")).toBeInTheDocument();
    expect(screen.getByRole("navigation", { name: "Sidebar navigation" })).toBeInTheDocument();
    expect(screen.queryByRole("navigation", { name: "Settings sections" })).not.toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Skills" })).toHaveAttribute(
      "aria-current",
      "page",
    );
    expect(document.title).toBe("Skills");

    fireEvent.click(screen.getByRole("button", { name: "Back to chat" }));
    expect(await screen.findByText(HERO_GREETING_PATTERN)).toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", { name: "Skills" }));
    expect(await screen.findByRole("heading", { name: "Skills" })).toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Open details for github" }));

    expect(await screen.findByRole("heading", { name: "github" })).toBeInTheDocument();
    const showMore = await screen.findByRole("button", { name: "Show more" });
    expect(showMore).toHaveAttribute("aria-expanded", "false");
    fireEvent.click(showMore);
    expect(screen.getByRole("button", { name: "Show less" })).toHaveAttribute(
      "aria-expanded",
      "true",
    );
    expect(screen.getByText("Setup required")).toBeInTheDocument();
    expect(screen.getByText("brew install gh")).toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Check again" })).toBeInTheDocument();
    fireEvent.click(screen.getByText("Skill instructions"));
    expect(screen.getByText(/Use GitHub CLI/)).toBeInTheDocument();
    const enabledSwitch = screen.getByRole("switch", { name: "Disable github" });
    expect(enabledSwitch).toHaveAttribute("aria-checked", "true");
    expect(enabledSwitch).toHaveClass("h-5", "w-9", "bg-foreground");
    fireEvent.click(enabledSwitch);
    await waitFor(() => {
      expect(screen.getByRole("switch", { name: "Enable github" })).toHaveAttribute(
        "aria-checked",
        "false",
      );
    });
    expect(screen.getByRole("switch", { name: "Enable github" })).toHaveClass("h-5", "w-9", "bg-muted-foreground/25");
  });

  it("deletes a custom skill from its detail sheet", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/cli-apps": { apps: [], installed_count: 0, catalog_updated_at: "2026-04-18" },
      "/api/settings/mcp-presets": { presets: [], installed_count: 0 },
      "/api/webui/skills": {
        skills: [
          {
            name: "custom-skill",
            description: "A workspace skill.",
            source: "workspace",
            enabled: true,
            deletable: true,
            available: true,
          },
        ],
      },
      "/api/webui/skills/custom-skill": {
        name: "custom-skill",
        description: "A workspace skill.",
        source: "workspace",
        enabled: true,
        deletable: true,
        available: true,
        requirements: {
          bins: [],
          env: [],
          missing_bins: [],
          missing_env: [],
        },
        raw_markdown: "---\nname: custom-skill\n---\nWorkspace instructions.",
      },
    });
    requestMutationSpy.mockResolvedValueOnce({
      skills: [],
      last_action: { name: "custom-skill", enabled: false, deleted: true },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Skills" }));
    fireEvent.click(
      await screen.findByRole("button", { name: "Open details for custom-skill" }),
    );
    expect(await screen.findByRole("heading", { name: "custom-skill" })).toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Delete" }));
    expect(screen.getByRole("heading", { name: "Delete custom-skill?" })).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Delete skill" }));

    await waitFor(() => {
      expect(
        screen.queryByRole("button", { name: "Open details for custom-skill" }),
      ).not.toBeInTheDocument();
    });
    expect(screen.getByText("No skills are available.")).toBeInTheDocument();
  });

  it("discovers and installs a skill from skills.sh", async () => {
    let finishInstall!: (value: unknown) => void;
    const pendingInstall = new Promise<unknown>((resolve) => {
      finishInstall = resolve;
    });
    const installedPayload = {
      skills: [
        {
          name: "react-testing",
          description: "Test React apps.",
          source: "workspace",
          available: true,
        },
        { name: "cron", description: "Schedule reminders.", source: "builtin", available: true },
      ],
      last_action: {
        installed: true,
        already_installed: false,
        name: "react-testing",
      },
    };
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/cli-apps": { apps: [], installed_count: 0, catalog_updated_at: "2026-04-18" },
      "/api/settings/mcp-presets": { presets: [], installed_count: 0 },
      "/api/webui/skills": {
        skills: [
          { name: "cron", description: "Schedule reminders.", source: "builtin", available: true },
        ],
      },
      "/api/webui/skills/trending?provider=all": {
        period: "mixed",
        provider: "all",
        install_supported: true,
        skills: [
          {
            id: "vercel-labs/skills/find-skills",
            skill_id: "find-skills",
            name: "find-skills",
            source: "vercel-labs/skills",
            provider: "skills_sh",
            installs: 14_481,
            url: "https://skills.sh/vercel-labs/skills/find-skills",
            installed: false,
            install_supported: true,
            metric: "installs_24h",
            rank: 18,
          },
          {
            id: "skillhub:ima-skills",
            skill_id: "ima-skills",
            name: "ima-skills",
            source: "@tencent-adm/ima-skills",
            provider: "skillhub",
            installs: 11_831,
            downloads: 142_525,
            url: "https://skillhub.cn/skills/tencent-adm/ima-skills",
            installed: false,
            install_supported: true,
            metric: "installs_total",
            version: "1.1.8",
            verified: true,
            rank: 1,
          },
        ],
      },
      "/api/webui/skills/trends?id=vercel-labs%2Fskills%2Ffind-skills": {
        trends: {
          "vercel-labs/skills/find-skills": [20, 32, 28, 45, 41, 50, 62, 58],
        },
      },
      "/api/webui/skills/search?q=React&provider=all": {
        query: "React",
        provider: "all",
        install_supported: true,
        skills: [
          {
            id: "acme/agent-skills/react-testing",
            skill_id: "react-testing",
            name: "React Testing",
            source: "acme/agent-skills",
            provider: "skills_sh",
            installs: 42,
            url: "https://skills.sh/acme/agent-skills/react-testing",
            installed: false,
            install_supported: true,
            metric: "installs_total",
          },
          {
            id: "skillhub:react",
            skill_id: "react",
            name: "React",
            source: "@ivangdavila/react",
            provider: "skillhub",
            installs: 693,
            downloads: 7_718,
            url: "https://skillhub.cn/skills/ivangdavila/react",
            installed: false,
            install_supported: true,
            metric: "installs_total",
            version: "1.0.4",
          },
        ],
      },
      "/api/webui/skills/trends?id=acme%2Fagent-skills%2Freact-testing": {
        trends: { "acme/agent-skills/react-testing": [] },
      },
    });
    requestMutationSpy.mockImplementationOnce(() => pendingInstall);

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Skills" }));
    const discoverTab = await screen.findByRole("tab", { name: "Discover" });
    expect(discoverTab.querySelector("svg")).toBeNull();
    fireEvent.click(discoverTab);
    expect(
      await screen.findByRole("heading", { name: "Popular skills" }),
    ).toBeInTheDocument();
    expect(screen.getByText("find-skills")).toBeInTheDocument();
    expect(screen.getByText("ima-skills")).toBeInTheDocument();
    expect(screen.getByRole("link", { name: "Open ima-skills on SkillHub" })).toHaveAttribute(
      "href", "https://skillhub.cn/skills/tencent-adm/ima-skills",
    );
    expect(screen.getAllByText("SkillHub")).toHaveLength(2);
    expect(screen.getAllByText("skills.sh")).toHaveLength(2);
    expect(screen.getByText(/14,481 installs \/ 24h/)).toBeInTheDocument();
    expect(screen.queryByText(/11,831 installs/)).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("tab", { name: "SkillHub" }));
    expect(screen.getByText("ima-skills")).toBeInTheDocument();
    expect(screen.queryByText("find-skills")).not.toBeInTheDocument();
    expect(
      vi.mocked(fetch).mock.calls.some(
        ([input]) =>
          String(input) === "/api/webui/skills/trending?provider=skillhub",
      ),
    ).toBe(false);
    fireEvent.click(screen.getByRole("tab", { name: "All" }));
    expect(screen.getByText("find-skills")).toBeInTheDocument();
    expect(screen.getByText("ima-skills")).toBeInTheDocument();
    expect(
      await screen.findByRole("img", { name: "8-week install trend" }),
    ).toBeInTheDocument();
    fireEvent.change(screen.getByRole("textbox", { name: "Search skills" }), {
      target: { value: "React" },
    });

    expect(await screen.findByText("React Testing")).toBeInTheDocument();
    expect(screen.getByRole("link", { name: "Open React on SkillHub" })).toHaveAttribute(
      "href", "https://skillhub.cn/skills/ivangdavila/react",
    );
    fireEvent.click(screen.getByRole("button", { name: "Install React Testing" }));
    expect(
      await screen.findByRole("heading", { name: "Install React Testing?" }),
    ).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Install skill" }));

    await waitFor(() => {
      expect(requestMutationSpy).toHaveBeenCalledWith(
        "skill.install",
        {
          provider: "skills_sh",
          source: "acme/agent-skills",
          skill: "react-testing",
        },
        150_000,
      );
    });
    fireEvent.click(screen.getByRole("tab", { name: "Installed" }));
    fireEvent.click(screen.getByRole("tab", { name: "Discover" }));
    expect(
      await screen.findByRole("button", { name: "Install find-skills" }),
    ).toBeDisabled();

    await act(async () => {
      finishInstall(installedPayload);
      await pendingInstall;
    });

    await waitFor(() => {
      expect(screen.getByRole("button", { name: "Install find-skills" })).toBeEnabled();
    });
    fireEvent.click(screen.getByRole("tab", { name: "Installed" }));
    expect(screen.getByText("react-testing")).toBeInTheDocument();
  });

  it("opens Automations from the main sidebar", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/webui/automations": {
        jobs: [
          {
            id: "job-1",
            name: "Daily repo check",
            enabled: true,
            protected: false,
            delete_after_run: false,
            schedule: { kind: "every", every_ms: 86_400_000 },
            payload: {
              message: "Check the repo status",
              kind: "agent_turn",
            },
            state: {
              next_run_at_ms: currentMonthTimestamp(17),
              last_status: "ok",
              pending: false,
              run_history: [],
            },
            origin: {
              session_key: "websocket:chat-a",
              channel: "websocket",
              chat_id: "chat-a",
              title: "Release prep",
              preview: "Check release blockers",
            },
          },
          {
            id: "external-quiz",
            name: "WeChat quiz",
            enabled: true,
            protected: false,
            delete_after_run: false,
            schedule: { kind: "cron", expr: "30 9-23 * * *", tz: "Asia/Shanghai" },
            payload: {
              message: "Send a quiz",
              kind: "agent_turn",
            },
            state: {
              next_run_at_ms: currentMonthTimestamp(17, 11, 30),
              last_status: "ok",
              pending: false,
              run_history: [],
            },
            origin: {
              channel: "weixin",
              title: "",
              preview: "",
            },
          },
          {
            id: "heartbeat",
            name: "heartbeat",
            enabled: true,
            protected: true,
            schedule: { kind: "every", every_ms: 60_000 },
            payload: { message: "", kind: "system_event" },
            state: { next_run_at_ms: null, pending: false, run_history: [] },
            origin: null,
          },
        ],
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const automationsButton = within(sidebar).getByRole("button", {
      name: "Automations",
    });

    fireEvent.click(automationsButton);

    const heading = await screen.findByRole(
      "heading",
      { name: "Automations" },
      { timeout: 5_000 },
    );
    expect(heading).toBeInTheDocument();
    const automationsMain = heading.closest("main");
    expect(automationsMain).not.toBeNull();
    expect(within(automationsMain as HTMLElement).queryByText("Settings")).not.toBeInTheDocument();
    expect((await screen.findAllByText(
      "Daily repo check",
      {},
      { timeout: 5_000 },
    )).length).toBeGreaterThanOrEqual(1);
    expect(screen.queryByText("Check the repo status")).not.toBeInTheDocument();
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: /Daily repo check/ }));
    expect(within(screen.getByRole("dialog", { name: "Daily repo check" })).getByText("Check the repo status")).toBeVisible();
    const detail = within(screen.getByRole("dialog", { name: "Daily repo check" }));
    expect(detail.queryByText("Release prep")).not.toBeInTheDocument();
    const user = userEvent.setup();
    await user.click(detail.getByRole("button", { name: "More actions" }));
    expect(screen.getByRole("menuitem", { name: "Open a chat" })).toHaveAttribute(
      "href", "#/chat/websocket%3Achat-a",
    );
    await user.keyboard("{Escape}");
    expect(detail.getByRole("button", { name: "More actions" })).toHaveFocus();
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    expect(screen.getByText("WeChat quiz")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: /WeChat quiz/ }));
    expect(screen.getByText("WeChat")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Close" }));
    expect(screen.queryByText("weixin:wx-chat")).not.toBeInTheDocument();
    expect(screen.queryByText("memory with dream state")).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: /heartbeat/ })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "System tasks 1" })).not.toBeInTheDocument();
    expect(screen.queryByText("heartbeat")).not.toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Automations" })).toHaveAttribute(
      "aria-current",
      "page",
    );
    expect(document.title).toBe("Automations");

  });

  it("keeps the automation chat link stable across live sidebar renames without duplicating titles", async () => {
    const key = "websocket:linked-chat";
    mockSessions = [{
      key, channel: "websocket", chatId: "linked-chat", createdAt: null, updatedAt: null,
      title: "Stored title", preview: "Original preview",
    }];
    const sidebarState: SidebarStatePayload = {
      schema_version: 1, pinned_keys: [], archived_keys: [], session_order: [],
      title_overrides: { [key]: "推特大战场" }, project_name_overrides: {},
      tags_by_key: {}, collapsed_groups: {}, workbench: { version: 1, tabs: {} },
      view: { density: "comfortable", show_archived: false, sort: "updated_desc" },
    };
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/webui/sidebar-state": sidebarState,
      "/api/webui/automations": { jobs: [{
        id: "reminder", name: "Drink water", enabled: true,
        schedule: { kind: "every", every_ms: 60_000 },
        payload: { message: "Take a break" },
        state: { next_run_at_ms: currentMonthTimestamp(17) },
        origin: { session_key: key, channel: "websocket", chat_id: "linked-chat",
          title: "Stored title", preview: "Original preview" },
      }] },
    });
    render(<App />);
    const sidebar = await screen.findByRole("navigation", { name: "Sidebar navigation" });
    await within(sidebar).findByRole("button", { name: "推特大战场" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Automations" }));
    fireEvent.click(await screen.findByRole("button", { name: /Drink water/ }));
    const dialog = screen.getByRole("dialog", { name: "Drink water" });
    expect(within(dialog).queryByText("推特大战场")).not.toBeInTheDocument();
    expect(within(dialog).queryByText("Stored title")).not.toBeInTheDocument();
    const user = userEvent.setup();
    await user.click(within(dialog).getByRole("button", { name: "More actions" }));
    expect(screen.getByRole("menuitem", { name: "Open a chat" })).toHaveAttribute(
      "href", "#/chat/websocket%3Alinked-chat",
    );
    for (const title of ["新会话名称", ""]) {
      act(() => {
        sidebarStateUpdateHandlers.forEach((handler) => handler({
          ...sidebarState, title_overrides: title ? { [key]: title } : {},
        }));
      });
      const expected = title || "Stored title";
      expect(within(sidebar).getByText(expected)).toBeInTheDocument();
      expect(within(dialog).queryByText(expected)).not.toBeInTheDocument();
      expect(screen.getByRole("menuitem", { name: "Open a chat" })).toHaveAttribute(
        "href", "#/chat/websocket%3Alinked-chat",
      );
    }
    await user.keyboard("{Escape}");
    expect(within(dialog).getByRole("button", { name: "More actions" })).toHaveFocus();
    expect(requestMutationSpy).not.toHaveBeenCalled();
  });

  it("edits a past one-time automation without resubmitting its old schedule", async () => {
    const pastOneShot = {
      id: "past-one-shot",
      name: "Past one-shot",
      enabled: true,
      protected: false,
      delete_after_run: true,
      schedule: { kind: "at", at_ms: 1 },
      payload: {
        message: "Old one-shot message",
        kind: "agent_turn",
      },
      state: {
        next_run_at_ms: null,
        last_run_at_ms: currentMonthTimestamp(12),
        last_status: "ok",
        pending: false,
        run_history: [],
      },
      origin: {
        session_key: "websocket:chat-a",
        channel: "websocket",
        chat_id: "chat-a",
        title: "Release prep",
        preview: "Check release blockers",
      },
    };
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/webui/automations": { jobs: [pastOneShot] },
    });
    requestMutationSpy.mockResolvedValueOnce({
      jobs: [{
        ...pastOneShot,
        payload: { ...pastOneShot.payload, message: "Updated one-shot message" },
      }],
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Automations" }));

    expect((await screen.findAllByText("Past one-shot")).length).toBeGreaterThanOrEqual(1);
    fireEvent.click(screen.getByRole("button", { name: /Past one-shot/ }));
    const runDetail = within(screen.getByRole("dialog", { name: "Past one-shot" }));
    expect(runDetail.getByText("Completed")).toBeVisible();
    expect(runDetail.queryByRole("button", { name: "Edit" })).not.toBeInTheDocument();
    fireEvent.click(runDetail.getByRole("button", { name: "Close" }));
    fireEvent.click(screen.getByRole("button", { name: "Tasks" }));
    fireEvent.click(screen.getByRole("button", { name: /Past one-shot/ }));
    fireEvent.click(screen.getByRole("button", { name: "Edit" }));
    await screen.findByRole("dialog", { name: "Edit task" });
    expect(screen.queryByText("Run time must be in the future.")).not.toBeInTheDocument();
    expect(
      screen.queryByText("Update the prompt and schedule. The linked chat stays unchanged."),
    ).not.toBeInTheDocument();
    expect(screen.getByDisplayValue("Old one-shot message")).toHaveClass(
      "min-h-[160px]",
      "resize-none",
    );

    fireEvent.change(screen.getByDisplayValue("Old one-shot message"), {
      target: { value: "Updated one-shot message" },
    });
    fireEvent.click(screen.getByRole("button", { name: "Save" }));

    await waitFor(() => {
      expect(requestMutationSpy).toHaveBeenCalledWith(
        "automation.update",
        {
          id: "past-one-shot",
          values: {
            name: "Past one-shot",
            message: "Updated one-shot message",
          },
        },
        20_000,
      );
    });
  });

  it("keeps long automation details expandable without nested scrolling", async () => {
    const longMessage = [
      "Review the release plan and prepare a concise status update for the channel.",
      "Include blockers, owners, follow-up dates, and any risky assumptions that changed since yesterday.",
      "Keep the output actionable and avoid repeating context that the team already confirmed in the thread.",
      "If a dependency looks stale, call it out explicitly and ask for a fresh owner update.",
      "This message is intentionally long enough to require progressive disclosure in the automation details panel.",
      "The full content should remain available without forcing the user into a small nested scroll area.",
    ].join("\n");
    const history = [
      { run_at_ms: currentMonthTimestamp(12), status: "error", duration_ms: 900, error: "oldest failure" },
      { run_at_ms: currentMonthTimestamp(13), status: "error", duration_ms: 800, error: "second oldest failure" },
      { run_at_ms: currentMonthTimestamp(14), status: "ok", duration_ms: 700 },
      { run_at_ms: currentMonthTimestamp(15), status: "ok", duration_ms: 600 },
      { run_at_ms: currentMonthTimestamp(16), status: "ok", duration_ms: 500 },
      { run_at_ms: currentMonthTimestamp(17), status: "ok", duration_ms: 400 },
    ];
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/webui/automations": {
        jobs: [
          {
            id: "long-details",
            name: "Long detail automation",
            enabled: true,
            protected: false,
            delete_after_run: false,
            schedule: { kind: "every", every_ms: 3_600_000 },
            payload: {
              message: longMessage,
              kind: "agent_turn",
            },
            state: {
              next_run_at_ms: currentMonthTimestamp(18),
              last_status: "ok",
              pending: false,
              run_history: history,
            },
            origin: {
              session_key: "websocket:chat-a",
              channel: "websocket",
              chat_id: "chat-a",
              title: "Release prep",
              preview: "Check release blockers",
            },
          },
        ],
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Automations" }));

    fireEvent.click(await screen.findByRole(
      "button",
      { name: /Long detail automation.*Planned/ },
      { timeout: 5_000 },
    ));
    const detailPanel = await screen.findByRole("dialog", { name: "Long detail automation" });
    const message = Array.from(detailPanel.querySelectorAll("section p")).find(
      (node) => node.textContent === longMessage,
    ) as HTMLElement | undefined;
    expect(message).toBeTruthy();
    const preview = message!.closest(".expandable-text")!;
    expect(preview).toHaveAttribute("data-state", "closed");

    fireEvent.click(within(detailPanel).getByRole("button", { name: "Show full message" }));
    expect(within(detailPanel).getByRole("button", { name: "Show less" })).toBeInTheDocument();
    expect(preview).toHaveAttribute("data-state", "open");
    expect(preview).toContainElement(message!);

    expect(within(detailPanel).queryByText("Recent health")).not.toBeInTheDocument();
    expect(within(detailPanel).queryByRole("button", { name: /Run history/ })).not.toBeInTheDocument();
    expect(within(detailPanel).queryByText(/oldest failure/)).not.toBeInTheDocument();
    expect(within(detailPanel).queryByText("No error recorded")).not.toBeInTheDocument();
  });

  it("localizes the Automations surface", async () => {
    await i18n.changeLanguage("zh-CN");
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/webui/automations": {
        jobs: [
          {
            id: "job-zh",
            name: "每日检查",
            enabled: true,
            protected: false,
            delete_after_run: false,
            schedule: { kind: "every", every_ms: 86_400_000 },
            payload: {
              message: "检查仓库状态",
              kind: "agent_turn",
            },
            state: {
              next_run_at_ms: currentMonthTimestamp(17),
              last_run_at_ms: currentMonthTimestamp(16),
              last_status: "ok",
              pending: false,
              run_history: [
                {
                  run_at_ms: currentMonthTimestamp(16),
                  status: "ok",
                  duration_ms: 500,
                },
              ],
            },
            origin: {
              session_key: "websocket:chat-a",
              channel: "websocket",
              chat_id: "chat-a",
              title: "发布准备",
              preview: "检查发布阻塞项",
            },
          },
        ],
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "侧边栏导航" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "自动任务" }));

    const heading = await screen.findByRole("heading", { name: "自动任务" });
    expect(heading).toBeInTheDocument();
    const automationsMain = heading.closest("main");
    expect(automationsMain).not.toBeNull();
    expect(within(automationsMain as HTMLElement).queryByText("设置")).not.toBeInTheDocument();
    expect(screen.queryByText("任务队列")).not.toBeInTheDocument();
    expect(screen.getAllByText("每日检查").length).toBeGreaterThanOrEqual(1);
    expect(screen.queryByText("检查仓库状态")).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: /每日检查.*计划运行/ }));
    const detail = within(screen.getByRole("dialog", { name: "每日检查" }));
    expect(detail.getByText("检查仓库状态")).toBeVisible();
    expect(detail.queryByText(/每 1天/)).not.toBeInTheDocument();
    fireEvent.click(detail.getByRole("button", { name: "任务信息" }));
    expect(within(screen.getByRole("dialog", { name: "任务信息" })).getByText(/每 1天/)).toBeVisible();
    expect(screen.queryByText("最近健康状态")).not.toBeInTheDocument();
    expect(screen.queryByText("近期无问题")).not.toBeInTheDocument();
    expect(screen.queryByText("Workspace automations")).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "刷新" })).not.toBeInTheDocument();
    expect(document.title).toBe("自动任务");
  });

  it("resizes the sidebar, collapses at the drag threshold and restores its saved width", async () => {
    const view = render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const handle = screen.getByRole("separator", { name: "Resize sidebar" });
    const sidebar = screen.getByTestId("host-sidebar-flow");
    expect(sidebar).toHaveClass("group/sidebar");
    fireEvent.pointerDown(handle, { button: 0, pointerId: 1, clientX: 272 });
    expect(sidebar).toHaveAttribute("data-resizing", "true");
    fireEvent.pointerMove(handle, { pointerId: 1, clientX: 360 });
    expect(sidebar).toHaveStyle({ width: "360px" });
    fireEvent.pointerUp(handle, { pointerId: 1, clientX: 360 });
    expect(sidebar).not.toHaveAttribute("data-resizing");
    expect(sidebar).toHaveStyle({ width: "360px" });
    expect(localStorage.getItem("nanobot-webui.sidebar.width")).toBe("360");
    fireEvent.pointerDown(handle, { button: 0, pointerId: 2, clientX: 360 });
    fireEvent.pointerMove(handle, { pointerId: 2, clientX: 150 });
    expect(sidebar).toHaveStyle({ width: "56px" });
    fireEvent.pointerMove(handle, { pointerId: 2, clientX: 180 });
    expect(sidebar).toHaveStyle({ width: "56px" });
    fireEvent.pointerMove(handle, { pointerId: 2, clientX: 240 });
    fireEvent.pointerUp(handle, { pointerId: 2, clientX: 240 });
    expect(sidebar).toHaveStyle({ width: "240px" });
    fireEvent.keyDown(handle, { key: "Enter" });
    expect(sidebar).toHaveStyle({ width: "56px" });
    view.unmount();
    render(<App />);
    await waitFor(() => expect(screen.getByTestId("host-sidebar-flow")).toHaveStyle({ width: "56px" }));
    fireEvent.click(within(screen.getByRole("navigation", { name: "Sidebar navigation" })).getByRole("button", { name: "Toggle sidebar" }));
    expect(screen.getByTestId("host-sidebar-flow")).toHaveStyle({ width: "240px" });
    fireEvent.keyDown(screen.getByRole("separator", { name: "Resize sidebar" }), { key: "ArrowRight" });
    expect(screen.getByTestId("host-sidebar-flow")).toHaveStyle({ width: "272px" });
  });

  it.each(["pointerUp", "pointerCancel", "lostPointerCapture"] as const)("keeps highlight easing while disabling navigation target lag until %s", async (finish) => {
    mockSessions = [{
      key: "websocket:resize-test", channel: "websocket", chatId: "resize-test",
      createdAt: "2026-04-16T10:00:00Z", updatedAt: "2026-04-16T10:00:00Z",
      title: "Resize test", preview: "",
    }];
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByTestId("host-sidebar-flow");
    await within(sidebar).findByTestId("chats-selection-highlight");
    const handle = within(sidebar).getByRole("separator", { name: "Resize sidebar" });
    for (const label of ["Apps", "Skills", "Automations", "Channels"]) {
      expect(within(sidebar).getByRole("button", { name: label })).toHaveClass(
        "group-data-[resizing=true]/sidebar:transition-none",
      );
    }
    for (const scope of ["actions", "chats"]) {
      const highlight = within(sidebar).getByTestId(`${scope}-selection-highlight`);
      expect(highlight).not.toHaveClass(
        "group-data-[resizing=true]/sidebar:transition-none",
      );
      expect(highlight).toHaveClass("sidebar-selection-highlight");
    }
    fireEvent.pointerDown(handle, { button: 0, pointerId: 1, clientX: 272 });
    fireEvent.pointerMove(handle, { pointerId: 1, clientX: 400 });
    expect(sidebar).toHaveAttribute("data-resizing", "true");
    expect(sidebar).toHaveStyle({ width: "400px" });
    fireEvent[finish](handle, { pointerId: 1, clientX: 400 });
    expect(sidebar).not.toHaveAttribute("data-resizing");
    expect(sidebar).toHaveClass("transition-[width]");
  });

  it("uses the shared sidebar controls and rail on the native host", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Desktop chat",
      },
    ];
    vi.mocked(fetchBootstrap).mockResolvedValue({
      token: "tok",
      api_token: "api-tok",
      ws_path: "/",
      expires_in: 300,
      runtime_surface: "native",
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const flowSidebar = screen.getByTestId("host-sidebar-flow");
    expect(flowSidebar).toHaveStyle({ width: "272px" });
    expect(screen.getByTestId("sidebar-brand-row")).toHaveClass("pt-3");
    expect(screen.getByTestId("sidebar-brand-mark")).toHaveClass("mt-5");
    expect(screen.getByRole("separator", { name: "Resize sidebar" })).toHaveAttribute("aria-valuenow", "272");
    expect(screen.queryByTestId("host-sidebar-toggle")).not.toBeInTheDocument();
    expect(
      screen.getByRole("navigation", { name: "Sidebar navigation" }),
    ).toBeInTheDocument();

    fireEvent.keyDown(screen.getByRole("separator", { name: "Resize sidebar" }), { key: "Enter" });
    await waitFor(() => expect(flowSidebar).toHaveStyle({ width: "56px" }));
    expect(
      screen.getByRole("navigation", { name: "Sidebar navigation" }),
    ).toBeInTheDocument();

    fireEvent.click(
      within(screen.getByRole("navigation", { name: "Sidebar navigation" }))
        .getByRole("button", { name: "Toggle sidebar" }),
    );
    await waitFor(() => expect(flowSidebar).toHaveStyle({ width: "272px" }));
  });

  it("aligns native settings navigation below the titlebar without extra top padding", async () => {
    vi.mocked(fetchBootstrap).mockResolvedValue({
      token: "tok",
      api_token: "api-tok",
      ws_path: "/",
      expires_in: 300,
      runtime_surface: "native",
    });
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Settings" }));

    const backButton = await screen.findByRole("button", { name: "Back to chat" });
    expect(backButton.closest("aside")).toHaveClass("pt-10", "lg:pt-10");
    expect(backButton.closest("aside")).not.toHaveClass("pt-[4.25rem]");
    expect(backButton).toHaveClass("-ml-1");
  });

  it("uses native chrome when the host bridge overrides browser gateway metadata", async () => {
    Reflect.set(window, "nanobotHost", { getRuntimeInfo: vi.fn() });
    vi.mocked(fetchBootstrap).mockResolvedValue({
      token: "tok",
      api_token: "api-tok",
      ws_path: "/",
      expires_in: 300,
      runtime_surface: "browser",
    });
    mockFetchRoutes({
      "/api/settings": {
        ...baseSettingsPayload(),
        surface: "browser",
        runtime_surface: "browser",
      },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    await waitFor(() => {
      expect(screen.getByTestId("sidebar-brand-mark")).toHaveClass("mt-5");
    });
    expect(document.documentElement).toHaveClass("native-host");
  });

  it("switches to the next session when deleting the active chat", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "First chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Second chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() =>
      expect(
        within(sidebar).getByRole("button", { name: /^First chat$/ }),
      ).toBeInTheDocument(),
    );

    fireEvent.pointerDown(screen.getByLabelText("Topic actions for First chat"), {
      button: 0,
    });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Delete" }));

    await waitFor(() =>
      expect(screen.getByText("Delete this topic?")).toBeInTheDocument(),
    );
    fireEvent.click(screen.getByRole("button", { name: "Delete" }));

    await waitFor(() =>
      expect(deleteChatSpy).toHaveBeenCalledWith("websocket:chat-a"),
    );
    await waitFor(() =>
      expect(
        within(sidebar).getByRole("button", { name: /^Second chat$/ }),
      ).toBeInTheDocument(),
    );
    expect(screen.queryByText("Delete this topic?")).not.toBeInTheDocument();
    expect(document.body.style.pointerEvents).not.toBe("none");
  }, 15_000);

  it.each([false, true])("archives only persisted selected topics in one sidebar update (draft=%s)", async (includeDraft) => {
    mockSessions = ["a", "b", "c"].map((id) => ({
      key: `websocket:chat-${id}`, channel: "websocket", chatId: `chat-${id}`,
      createdAt: "2026-04-16T10:00:00Z", updatedAt: "2026-04-16T10:00:00Z",
      title: `Topic ${id}`, preview: "",
      projectLocked: includeDraft && id === "a" ? false : undefined,
    }));
    mockFetchRoutes({
      "/api/webui/sidebar-state": { pinned_keys: ["websocket:chat-a", "websocket:chat-b"] },
    });
    window.history.replaceState(null, "", "/#/chat/websocket%3Achat-a");
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => statusHandlers.forEach((handler) => handler("open")));
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await within(sidebar).findByRole("button", { name: "Topic a" });
    fireEvent.pointerDown(within(sidebar).getByLabelText("Topic actions for Topic a"), { button: 0 });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Select" }));
    fireEvent.click(within(sidebar).getByRole("button", { name: "Topic b" }));
    fireEvent.click(within(sidebar).getByRole("button", { name: "Archive" }));
    const dialog = await screen.findByRole("alertdialog", {
      name: includeDraft ? "Archive this topic?" : "Archive 2 topics?",
    });
    expect(setSidebarStateSpy).not.toHaveBeenCalled();
    fireEvent.click(within(dialog).getByRole("button", { name: "Archive" }));

    await waitFor(() => expect(setSidebarStateSpy).toHaveBeenCalledTimes(1));
    expect(setSidebarStateSpy).toHaveBeenCalledWith(expect.objectContaining({
      archived_keys: includeDraft ? ["websocket:chat-b"] : ["websocket:chat-a", "websocket:chat-b"],
      pinned_keys: includeDraft ? ["websocket:chat-a"] : [],
    }));
    expect(window.location.hash).toBe(includeDraft ? "#/chat/websocket%3Achat-a" : "#/chat/websocket%3Achat-c");
    expect(within(sidebar).getByRole("button", { name: "Topic c" })).toBeInTheDocument();
    if (includeDraft) expect(within(sidebar).getByRole("button", { name: "Topic a" })).toBeInTheDocument();
    else expect(within(sidebar).queryByRole("button", { name: "Topic a" })).not.toBeInTheDocument();
    expect(within(sidebar).queryByRole("button", { name: "Topic b" })).not.toBeInTheDocument();
    expect(deleteChatSpy).not.toHaveBeenCalled();
  });

  it("deletes multiple selected topics through one confirmation", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "First chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Second chat",
      },
      {
        key: "websocket:chat-c",
        channel: "websocket",
        chatId: "chat-c",
        createdAt: "2026-04-16T12:00:00Z",
        updatedAt: "2026-04-16T12:00:00Z",
        preview: "Third chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.pointerDown(within(sidebar).getByLabelText(
      "Topic actions for First chat",
    ), { button: 0 });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Select" }));
    fireEvent.click(within(sidebar).getByRole("button", { name: "Second chat" }));
    expect(within(sidebar).getByText("2 selected")).toBeInTheDocument();

    const automationReads: Array<(jobs: SessionAutomationJob[]) => void> = [];
    getSessionAutomationsSpy.mockImplementation(() => new Promise((resolve) => automationReads.push(resolve)));
    fireEvent.click(within(sidebar).getByRole("button", { name: "Delete" }));
    fireEvent.click(document.body);
    expect(screen.getByTestId("delete-selection-bar")).toHaveTextContent("2 selected");
    expect(deleteChatSpy).not.toHaveBeenCalled();
    await act(async () => automationReads.forEach((resolve) => resolve([])));
    expect(await screen.findByText("Delete 2 conversations?")).toBeInTheDocument();
    fireEvent.keyDown(screen.getByRole("alertdialog"), { key: "Escape" });
    expect(screen.getByTestId("delete-selection-bar")).toHaveTextContent("2 selected");
    expect(deleteChatSpy).not.toHaveBeenCalled();

    getSessionAutomationsSpy.mockResolvedValue([]);
    fireEvent.click(within(sidebar).getByRole("button", { name: "Delete" }));
    expect(await screen.findByText("Delete 2 conversations?")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Delete" }));
    expect(screen.queryByTestId("delete-selection-bar")).not.toBeInTheDocument();

    await waitFor(() => expect(deleteChatSpy).toHaveBeenCalledTimes(2));
    expect(deleteChatSpy.mock.calls.map(([key]) => key)).toEqual([
      "websocket:chat-a",
      "websocket:chat-b",
    ]);
    expect(getSessionAutomationsSpy).toHaveBeenCalledWith("websocket:chat-a");
    expect(getSessionAutomationsSpy).toHaveBeenCalledWith("websocket:chat-b");
    expect(within(sidebar).getByRole("button", { name: "Third chat" }))
      .toBeInTheDocument();
  }, 15_000);

  it("shows localized bound automations in the first delete confirmation", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "First chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Second chat",
      },
    ];
    getSessionAutomationsSpy.mockResolvedValue([
      {
        id: "job-1",
        name: "Daily repo check",
        enabled: true,
        schedule: { kind: "every", every_ms: 86_400_000 },
        payload: { message: "Check the repo" },
        state: { next_run_at_ms: Date.UTC(2026, 3, 17, 10, 0, 0) },
      },
    ]);
    await i18n.changeLanguage("zh-CN");

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "侧边栏导航" });
    await waitFor(() =>
      expect(
        within(sidebar).getByRole("button", { name: /^First chat$/ }),
      ).toBeInTheDocument(),
    );

    fireEvent.pointerDown(screen.getByLabelText(/First chat.*话题操作/), {
      button: 0,
    });
    fireEvent.click(await screen.findByRole("menuitem", { name: "删除" }));

    await waitFor(() =>
      expect(screen.getByText("Daily repo check")).toBeInTheDocument(),
    );
    expect(getSessionAutomationsSpy).toHaveBeenCalledWith("websocket:chat-a");
    expect(
      screen.getByText("删除话题也会删除关联的自动任务"),
    ).toBeInTheDocument();
    expect(
      screen.queryByText("Deleting this topic also deletes its linked automations."),
    ).not.toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "删除" }));

    await waitFor(() =>
      expect(deleteChatSpy).toHaveBeenCalledWith("websocket:chat-a", {
        deleteAutomations: true,
      }),
    );
    expect(deleteChatSpy).toHaveBeenCalledTimes(1);
    expect(screen.queryByText("Daily repo check")).not.toBeInTheDocument();
  }, 15_000);

  it("closes the mobile drawer when selecting a new or current topic without a search tooltip", async () => {
    restoreBrowserFocus = mockBrowserFocus();
    const user = userEvent.setup();
    mockSessions = ["First", "Second"].map((title, index) => ({
      key: `websocket:mobile-${index}`,
      channel: "websocket",
      chatId: `mobile-${index}`,
      createdAt: "2026-04-16T10:00:00Z",
      updatedAt: "2026-04-16T10:00:00Z",
      preview: `${title} mobile chat`,
    }));
    vi.stubGlobal("matchMedia", vi.fn().mockImplementation((query: string) => ({
      matches: !query.includes("1024px"),
      media: query,
      onchange: null,
      addListener: vi.fn(),
      removeListener: vi.fn(),
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      dispatchEvent: vi.fn(),
    })));

    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    for (const title of ["First", "First", "Second"]) {
      await user.click(await screen.findByRole("button", { name: "Toggle sidebar" }));
      const sheet = await screen.findByRole("dialog");
      await waitFor(() => expect(sheet).toHaveFocus());
      expect(screen.queryByRole("tooltip")).not.toBeInTheDocument();
      await user.click(await within(sheet).findByRole("button", { name: `${title} mobile chat` }));
      await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
      await waitFor(() => expect(document.title).toBe(`${title} mobile chat`));
      expect(screen.getByRole("button", { name: `${title} mobile chat` }))
        .toHaveAttribute("aria-current", "page");
    }
  });

  it("keeps the mobile session action menu inside the sidebar sheet", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Existing chat",
      },
    ];
    vi.stubGlobal(
      "matchMedia",
      vi.fn().mockImplementation((query: string) => ({
        matches: !query.includes("1024px"),
        media: query,
        onchange: null,
        addListener: vi.fn(),
        removeListener: vi.fn(),
        addEventListener: vi.fn(),
        removeEventListener: vi.fn(),
        dispatchEvent: vi.fn(),
      })),
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.click(screen.getByRole("button", { name: "Toggle sidebar" }));

    const sheet = await screen.findByRole("dialog");
    const mobileSidebar = within(sheet).getByRole("navigation", {
      name: "Sidebar navigation",
    });
    await waitFor(() =>
      expect(
        within(mobileSidebar).getByRole("button", { name: /^Existing chat$/ }),
      ).toBeInTheDocument(),
    );

    fireEvent.pointerDown(
      within(mobileSidebar).getByLabelText("Topic actions for Existing chat"),
      { button: 0 },
    );

    const deleteItem = await within(sheet).findByRole("menuitem", {
      name: "Delete",
    });
    expect(deleteItem).toBeInTheDocument();

    fireEvent.click(deleteItem);
    await waitFor(() =>
      expect(screen.getByText("Delete this topic?")).toBeInTheDocument(),
    );
  }, 15_000);

  it("renames inline in the mobile drawer without dismissing it and reloads the saved title", async () => {
    restoreBrowserFocus = mockBrowserFocus();
    const user = userEvent.setup();
    mockSessions = [{
      key: "websocket:chat-a", channel: "websocket", chatId: "chat-a",
      createdAt: null, updatedAt: null, title: "Existing chat", preview: "",
    }];
    vi.stubGlobal("matchMedia", vi.fn().mockImplementation((query: string) => ({
      matches: !query.includes("1024px"), media: query, onchange: null,
      addListener: vi.fn(), removeListener: vi.fn(), addEventListener: vi.fn(),
      removeEventListener: vi.fn(), dispatchEvent: vi.fn(),
    })));
    const persisted: { state?: SidebarStatePayload } = {};
    mockFetchRoutes({ "/api/webui/sidebar-state": () => persisted.state ?? {} });
    setSidebarStateSpy.mockImplementation(async (state: SidebarStatePayload) => {
      persisted.state = state;
      return state;
    });
    const firstRender = render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => statusHandlers.forEach((handler) => handler("open")));
    const route = window.location.hash;
    await user.click(await screen.findByRole("button", { name: "Toggle sidebar" }));
    const sheet = await screen.findByRole("dialog");
    const startRename = async () => {
      await user.click(within(sheet).getByRole("button", { name: "Topic actions for Existing chat" }));
      await user.click(await within(sheet).findByRole("menuitem", { name: "Rename" }));
      return within(sheet).getByRole("textbox", { name: "Topic name" });
    };
    const firstInput = await startRename();
    expect(screen.getAllByRole("dialog")).toHaveLength(1);
    fireEvent.compositionStart(firstInput);
    fireEvent.keyDown(firstInput, { key: "Escape" });
    expect(firstInput).toBeInTheDocument();
    expect(sheet).toBeInTheDocument();
    fireEvent.compositionEnd(firstInput);
    fireEvent.keyDown(firstInput, { key: "Escape" });
    expect(within(sheet).queryByRole("textbox")).not.toBeInTheDocument();
    expect(sheet).toBeInTheDocument();

    const input = await startRename();
    await user.clear(input);
    await user.type(input, "Renamed topic");
    setSidebarStateSpy.mockRejectedValueOnce(new Error("Disk full"));
    await user.keyboard("{Enter}");
    expect(await within(sheet).findByRole("alert")).toHaveTextContent("Couldn't save the name. Try again.");
    expect(input).toHaveValue("Renamed topic");
    expect(persisted.state?.title_overrides["websocket:chat-a"]).toBeUndefined();
    await user.keyboard("{Enter}");
    expect(await within(sheet).findByRole("button", { name: "Renamed topic" })).toBeInTheDocument();
    expect(persisted.state?.title_overrides["websocket:chat-a"]).toBe("Renamed topic");
    expect(window.location.hash).toBe(route);
    expect(screen.getAllByRole("dialog")).toHaveLength(1);
    firstRender.unmount();
    render(<App />);
    expect(await screen.findByRole("button", { name: "Renamed topic" })).toBeInTheDocument();
  });

  it.each([false, true])("uses renamed topic titles in mention candidates and sends across reloads (split=%s)", async (split) => {
    restoreBrowserFocus = mockBrowserFocus();
    const user = userEvent.setup();
    const target: ChatSummary = {
      key: "websocket:target", channel: "websocket", chatId: "target",
      createdAt: null, updatedAt: null, title: "Generated title", preview: "Original question",
      handle: { id: "handle_0123456789abcdef0123456789abcdef", name: "gane" },
    };
    mockSessions = [
      { ...target, key: "websocket:source", chatId: "source", title: "Source", handle: undefined },
      { ...target, key: "websocket:second", chatId: "second", title: "Second", handle: undefined },
      target,
    ];
    window.history.replaceState(null, "", split ? "/#/chat/websocket%3Asource" : "/#/new");
    let persisted = {
      workbench: { version: 1, tabs: split ? {
        "tab:websocket:source": {
          explicit: true, title: "Workspace", paneKeys: ["websocket:source", "websocket:second"],
          layout: "columns",
        },
      } : {} },
    } as Partial<SidebarStatePayload>;
    mockFetchRoutes({ "/api/webui/sidebar-state": () => persisted });
    setSidebarStateSpy.mockImplementation(async (state: SidebarStatePayload) => {
      persisted = state;
      return state;
    });
    const firstRender = render(<App />);
    await act(async () => { await import("@/components/thread/ThreadShell"); });
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => statusHandlers.forEach((handler) => handler("open")));
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await user.click(await within(sidebar).findByRole("button", { name: "Topic actions for Generated title" }));
    await user.click(await screen.findByRole("menuitem", { name: "Rename" }));
    const name = screen.getByRole("textbox", { name: "Topic name" });
    await user.clear(name);
    await user.type(name, "会话编辑{Enter}");
    await within(sidebar).findByText("会话编辑");
    expect(persisted.title_overrides?.[target.key]).toBe("会话编辑");

    const input = screen.getByRole("textbox", { name: /^Message / });
    fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });
    expect(screen.getByRole("option", { name: /@gane/ })).toHaveTextContent("会话编辑");
    fireEvent.change(input, { target: { value: "@会话", selectionStart: 3 } });
    expect(screen.getByRole("option", { name: /@gane/ })).toHaveTextContent("会话编辑");
    fireEvent.keyDown(input, { key: "Tab" });
    fireEvent.keyDown(input, { key: "Escape" });
    expect(input).toHaveValue("@gane ");
    expect(screen.getByTestId("composer-session-mention-gane")).toHaveAttribute("title", "Session: 会话编辑");
    fireEvent.keyDown(input, { key: "Enter" });
    await waitFor(() => expect(sendMessageSpy).toHaveBeenCalled());
    expect(sendMessageSpy.mock.calls.at(-1)?.[3]?.sessionMentions).toEqual([{
      id: target.handle?.id, name: "gane", session_key: target.key, title: "会话编辑",
    }]);

    firstRender.unmount();
    render(<App />);
    await screen.findByText("会话编辑");
    const restoredInput = await screen.findByRole("textbox", { name: /^Message / });
    fireEvent.change(restoredInput, { target: { value: "@gane", selectionStart: 5 } });
    expect(screen.getByRole("option", { name: /@gane/ })).toHaveTextContent("会话编辑");
  });

  it("searches the full preview of a session without a custom title", async () => {
    restoreBrowserFocus = mockBrowserFocus();
    const preview = `Review notes ${"alpha ".repeat(10)}orangeunique`;
    mockSessions = [{
      key: "websocket:target", channel: "websocket", chatId: "target",
      createdAt: null, updatedAt: null, title: "", preview,
      handle: { id: "handle_0123456789abcdef0123456789abcdef", name: "gane" },
    }];
    window.history.replaceState(null, "", "/#/new");
    render(<App />);
    await act(async () => { await import("@/components/thread/ThreadShell"); });
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => statusHandlers.forEach((handler) => handler("open")));
    const input = screen.getByRole("textbox", { name: /^Message / });
    fireEvent.change(input, { target: { value: "@orangeunique", selectionStart: 13 } });
    expect(screen.getByRole("option", { name: /@gane/ })).toHaveTextContent("orangeunique");
  });

  it("retries a failed sidebar read before enabling edits without losing saved state", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "First chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Second chat",
      },
    ];
    const initialState = {
      schema_version: 1,
      pinned_keys: ["websocket:chat-b"],
      archived_keys: ["websocket:chat-a"],
      title_overrides: { "websocket:chat-b": "Roadmap" },
      tags_by_key: {},
      collapsed_groups: {},
      view: {
        density: "comfortable",
        show_archived: false,
        sort: "updated_desc",
      },
      updated_at: null,
    };
    let sidebarReads = 0;
    vi.stubGlobal(
      "fetch",
      vi.fn().mockImplementation(async (url: string | URL | Request) => {
        const href = String(url);
        if (href === "/api/webui/sidebar-state") {
          if (++sidebarReads === 1) throw new Error("Gateway restarting");
          return { ok: true, json: async () => initialState };
        }
        return { ok: false, status: 404 };
      }),
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => {
      statusHandlers.forEach((handler) => handler("open"));
    });
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(sidebar).getByText("Loading…")).toBeInTheDocument();
    expect(setSidebarStateSpy).not.toHaveBeenCalled();
    await waitFor(() =>
      expect(within(sidebar).getByText("Pinned")).toBeInTheDocument(),
      { timeout: 5_000 },
    );
    expect(within(sidebar).getByRole("button", { name: /^Roadmap$/ })).toBeInTheDocument();
    expect(within(sidebar).queryByRole("button", { name: /^First chat$/ })).not.toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", { name: "Show archived" }));
    await waitFor(() =>
      expect(within(sidebar).getByText("Archived")).toBeInTheDocument(),
    );
    expect(within(sidebar).getByRole("button", { name: /^First chat$/ })).toBeInTheDocument();
    expect(setSidebarStateSpy).toHaveBeenCalledWith(
      expect.objectContaining({
        pinned_keys: initialState.pinned_keys,
        archived_keys: initialState.archived_keys,
        title_overrides: initialState.title_overrides,
        view: expect.objectContaining({ show_archived: true }),
      }),
    );

    expect(within(sidebar).queryByRole("button", { name: "View" })).not.toBeInTheDocument();
  }, 10_000);

  it.each([false, true])("preserves sidebar metadata and panes after both reads fail with partial cache: %s", async (cached) => {
    const actual = await vi.importActual<typeof import("@/hooks/useSessions")>("@/hooks/useSessions");
    vi.mocked(useSessions).mockImplementation(actual.useSessions);
    const sessions: ChatSummary[] = ["a", "b"].map((id) => ({
      key: `websocket:chat-${id}`, channel: "websocket", chatId: `chat-${id}`,
      createdAt: null, updatedAt: null, preview: "",
    }));
    if (cached) {
      activateReloadCache("ws://test");
      writeReloadCache("sessions", sessions.slice(0, 1));
    }
    const saved = {
      schema_version: 1,
      pinned_keys: ["websocket:chat-b", "websocket:deleted"],
      archived_keys: ["websocket:deleted"],
      session_order: ["websocket:chat-a", "websocket:chat-b", "websocket:deleted"],
      title_overrides: {
        "websocket:chat-a": "Saved A", "websocket:chat-b": "Saved B", "websocket:deleted": "Old topic",
      },
      project_name_overrides: {},
      tags_by_key: { "websocket:chat-b": ["important"], "websocket:deleted": ["old"] },
      collapsed_groups: {},
      workbench: {
        version: 1,
        tabs: {
          "tab:saved": {
            explicit: true, title: "Saved group",
            paneKeys: ["websocket:chat-a", "websocket:chat-b", "websocket:deleted"],
            layoutPaneKeys: ["websocket:chat-b", "websocket:chat-a", "websocket:deleted"],
            layout: "columns", splitRatios: [0.4, 0.6],
          },
        },
      },
      view: {
        density: "comfortable", show_archived: false, sort: "updated_desc",
      },
      updated_at: null,
    };
    let sidebarReads = 0;
    let sessionsFail = true;
    let serverSessions = sessions;
    vi.stubGlobal("fetch", vi.fn(async (input: RequestInfo | URL) => {
      if (String(input) === "/api/sessions") {
        return sessionsFail
          ? Response.json({}, { status: 503 })
          : jsonResponse({ sessions: serverSessions });
      }
      if (String(input) === "/api/webui/sidebar-state") {
        return ++sidebarReads === 1
          ? Response.json({}, { status: 503 })
          : jsonResponse(saved);
      }
      return Response.json({}, { status: 404 });
    }));

    const markersKey = "nanobot-webui.sidebar.session-updates.v1";
    localStorage.setItem(markersKey, JSON.stringify(["chat-b", "deleted"]));
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => statusHandlers.forEach((handler) => handler("open")));
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(sidebar).getByText("Loading…")).toBeInTheDocument();
    await waitFor(() => expect(sidebarReads).toBe(2), { timeout: 5_000 });
    await act(async () => {});
    expect(within(sidebar).queryByText("Loading…")).not.toBeInTheDocument();
    expect(setSidebarStateSpy).not.toHaveBeenCalled();
    expect(JSON.parse(localStorage.getItem(markersKey)!)).toEqual(["chat-b", "deleted"]);

    // A successful full list can authorize removal; the failed read and cache cannot.
    sessionsFail = false;
    act(() => sessionUpdateHandlers.forEach((handler) => handler("chat-a")));
    await within(sidebar).findByRole("button", { name: "Group: Saved group" });
    expect(await within(sidebar).findByRole("button", { name: "Saved B" })).toBeInTheDocument();
    await waitFor(() => expect(setSidebarStateSpy).toHaveBeenLastCalledWith({
      ...saved,
      view: expect.objectContaining(saved.view),
      pinned_keys: ["websocket:chat-b"],
      archived_keys: [],
      session_order: ["websocket:chat-a", "websocket:chat-b"],
      title_overrides: { "websocket:chat-a": "Saved A", "websocket:chat-b": "Saved B" },
      tags_by_key: { "websocket:chat-b": ["important"] },
      workbench: {
        version: 1,
        tabs: {
          "tab:saved": {
            ...saved.workbench.tabs["tab:saved"],
            paneKeys: ["websocket:chat-a", "websocket:chat-b"],
            layoutPaneKeys: ["websocket:chat-b", "websocket:chat-a"],
            splitRatios: [],
          },
        },
      },
    }));

    expect(JSON.parse(localStorage.getItem(markersKey)!)).toEqual(["chat-b"]);
    serverSessions = [];
    act(() => sessionUpdateHandlers.forEach((handler) => handler("chat-a")));
    await waitFor(() => expect(setSidebarStateSpy).toHaveBeenLastCalledWith({
      ...saved, view: expect.objectContaining(saved.view),
      pinned_keys: [], archived_keys: [], session_order: [],
      title_overrides: {}, tags_by_key: {}, workbench: { version: 1, tabs: {} },
    }));
    expect(JSON.parse(localStorage.getItem(markersKey)!)).toEqual([]);
  }, 10_000);

  it("sorts chats by displayed title when A-Z is persisted", async () => {
    mockSessions = [
      {
        key: "websocket:zulu",
        channel: "websocket",
        chatId: "zulu",
        createdAt: "2026-04-16T12:00:00Z",
        updatedAt: "2026-04-16T12:00:00Z",
        title: "Zulu work",
        preview: "later",
      },
      {
        key: "websocket:new",
        channel: "websocket",
        chatId: "new",
        createdAt: "2026-04-15T12:00:00Z",
        updatedAt: "2026-04-15T12:00:00Z",
        preview: "hi nanobot",
      },
      {
        key: "websocket:alpha",
        channel: "websocket",
        chatId: "alpha",
        createdAt: "2026-04-14T12:00:00Z",
        updatedAt: "2026-04-14T12:00:00Z",
        title: "Alpha plan",
        preview: "earlier",
      },
    ];
    const initialState = {
      schema_version: 1,
      pinned_keys: [],
      archived_keys: [],
      title_overrides: {},
      tags_by_key: {},
      collapsed_groups: {},
      view: {
        density: "comfortable",
        show_archived: false,
        sort: "title_asc",
      },
      updated_at: null,
    };
    vi.stubGlobal(
      "fetch",
      vi.fn().mockImplementation(async (url: string | URL | Request) => {
        const href = String(url);
        if (href === "/api/webui/sidebar-state") {
          return { ok: true, json: async () => initialState };
        }
        return { ok: false, status: 404 };
      }),
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() =>
      expect(within(sidebar).getByText("Topics")).toBeInTheDocument(),
    );
    const group = within(sidebar).getByText("Topics").closest("section");
    expect(group).toBeTruthy();
    const labels = within(group as HTMLElement)
      .getAllByRole("button")
      .map((button) => button.textContent?.trim())
      .filter(Boolean);

    expect(labels).toEqual(["Alpha plan", "New topic", "Zulu work"]);
  });

  it("shows running and completed session indicators in the sidebar", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Working chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Quiet chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() =>
      expect(
        within(sidebar).getByRole("button", { name: /^Working chat$/ }),
      ).toBeInTheDocument(),
    );

    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(12_345));
    });
    expect(within(sidebar).getByRole("img", { name: "Agent running" })).toBeInTheDocument();

    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(null));
    });
    expect(within(sidebar).queryByRole("img", { name: "Agent running" }))
      .not.toBeInTheDocument();
    expect(within(sidebar).getByRole("img", { name: "New activity" })).toBeInTheDocument();

    await act(async () => {
      fireEvent.click(within(sidebar).getByRole("button", { name: /^Working chat$/ }));
    });
    expect(within(sidebar).queryByRole("img", { name: "New activity" }))
      .not.toBeInTheDocument();
  });

  it("does not show an updated dot later when the active session finishes", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Active work",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Other chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() =>
      expect(
        within(sidebar).getByRole("button", { name: /^Active work$/ }),
      ).toBeInTheDocument(),
    );

    await act(async () => {
      fireEvent.click(within(sidebar).getByRole("button", { name: /^Active work$/ }));
    });
    await waitFor(() => expect(document.title).toContain("Active work"));

    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(12_345));
    });
    expect(within(sidebar).getByRole("img", { name: "Agent running" })).toBeInTheDocument();

    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(null));
    });
    expect(within(sidebar).queryByRole("img", { name: "Agent running" }))
      .not.toBeInTheDocument();
    expect(within(sidebar).queryByRole("img", { name: "New activity" }))
      .not.toBeInTheDocument();

    await act(async () => {
      fireEvent.click(within(sidebar).getByRole("button", { name: /^Other chat$/ }));
    });
    expect(within(sidebar).queryByRole("img", { name: "New activity" }))
      .not.toBeInTheDocument();
  });

  it("marks inactive sessions when a thread update arrives", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Open chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Scheduled update target",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await act(async () => {
      fireEvent.click(within(sidebar).getByRole("button", { name: /^Open chat$/ }));
    });

    act(() => {
      for (const handler of sessionUpdateHandlers) handler("chat-b", "thread");
    });

    expect(within(sidebar).getByRole("img", { name: "New activity" })).toBeInTheDocument();

    await act(async () => {
      fireEvent.click(within(sidebar).getByRole("button", { name: /^Scheduled update target$/ }));
    });

    expect(within(sidebar).queryByRole("img", { name: "New activity" }))
      .not.toBeInTheDocument();
  });

  it("restores sidebar runs from lifecycle replay without reviving them from stale session rows", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Running after reload",
        runStartedAt: 12_345,
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Completed after reload",
      },
    ];
    localStorage.setItem(
      "nanobot-webui.sidebar.session-updates.v1",
      JSON.stringify(["chat-b"]),
    );

    const { rerender } = render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() => expect(attachSpy).toHaveBeenCalledWith("chat-a"));
    expect(within(sidebar).queryByRole("img", { name: "Agent running" })).not.toBeInTheDocument();
    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(12_345));
    });
    expect(within(sidebar).getByRole("img", { name: "Agent running" })).toBeInTheDocument();
    expect(within(sidebar).getByRole("img", { name: "New activity" })).toBeInTheDocument();
    act(() => {
      for (const handler of runStatusHandlers) handler("chat-a", runState(null));
    });
    mockSessions = mockSessions.map((session) => ({ ...session }));
    rerender(<App />);
    expect(within(sidebar).queryByRole("img", { name: "Agent running" })).not.toBeInTheDocument();
  });

  it("restores the active chat from the URL hash after a page reload", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Active after reload",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Other chat",
      },
    ];
    window.history.replaceState(
      null,
      "",
      `/#/chat/${encodeURIComponent("websocket:chat-a")}`,
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    await waitFor(() => expect(document.title).toBe("Active after reload"));
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(
      within(sidebar).getByRole("button", { name: /^Active after reload$/ }),
    ).toBeInTheDocument();
    expect(window.location.hash).toBe(
      `#/chat/${encodeURIComponent("websocket:chat-a")}`,
    );
  });

  it("opens the settings view from the sidebar footer", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/version-check": { updateAvailable: null },
    });
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.click(within(screen.getByRole("navigation", { name: "Sidebar navigation" }))
      .getByRole("button", { name: "Settings" }));
    await act(async () => { await import("@/components/settings/SettingsView"); });
    const nav = await screen.findByRole("navigation", { name: "Settings sections" });
    for (const name of ["Overview", "Appearance", "Models", "Capabilities", "System", "Advanced", "About"]) {
      expect(within(nav).getByRole("button", { name })).toBeInTheDocument();
    }
    fireEvent.click(within(nav).getByRole("button", { name: "Appearance" }));
    expect(await screen.findByRole("switch", { name: "Brand logos" })).toBeInTheDocument();
    fireEvent.click(within(nav).getByRole("button", { name: "Models" }));
    expect(await screen.findByText("Model presets")).toBeInTheDocument();
    fireEvent.click(within(nav).getByRole("button", { name: "Capabilities" }));
    expect(screen.getByRole("switch", { name: "Image generation" })).toBeInTheDocument();
    fireEvent.click(within(nav).getByRole("button", { name: "About" }));
    expect(await screen.findByText("You're up to date")).toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Check again" })).toBeInTheDocument();
  });

  it.each([true, false])("completes focused settings edits before history changes section (saved=%s)", async (saved) => {
    const payload = { ...baseSettingsPayload(), transcription: { ...DEFAULT_TRANSCRIPTION_SETTINGS, language: "en" } };
    mockFetchRoutes({ "/api/settings": payload });
    let resolveSave!: (value: unknown) => void;
    let rejectSave!: (error: Error) => void;
    requestMutationSpy.mockImplementationOnce(() => new Promise((resolve, reject) => { resolveSave = resolve; rejectSave = reject; }));
    window.history.replaceState(null, "", "/#/settings?section=voice");
    render(<App />);
    await act(async () => { await import("@/components/settings/SettingsView"); });
    const language = await screen.findByPlaceholderText("Auto");
    fireEvent.focus(language);
    fireEvent.change(language, { target: { value: "ja" } });
    expect(requestMutationSpy).not.toHaveBeenCalled();
    act(() => {
      window.history.replaceState(null, "", "/#/settings?section=models");
      window.dispatchEvent(new PopStateEvent("popstate"));
    });
    await waitFor(() => expect(requestMutationSpy).toHaveBeenCalledWith(
      "settings.transcription.update", expect.objectContaining({ language: "ja" }), 20_000,
    ));
    expect(window.location.hash).toBe("#/settings?section=voice");
    expect(language).toHaveValue("ja");
    await act(async () => {
      if (saved) resolveSave({ ...payload, transcription: { ...payload.transcription, language: "ja" } });
      else rejectSave(new Error("Save failed"));
    });
    if (saved) {
      await waitFor(() => expect(window.location.hash).toBe("#/settings?section=models"));
      expect(await screen.findByText("Model presets")).toBeInTheDocument();
    } else {
      expect(window.location.hash).toBe("#/settings?section=voice");
      expect(language).toHaveValue("ja");
      expect(await screen.findByText("Save failed")).toBeVisible();
    }
  });

  it("retains a capability draft while opening provider configuration", async () => {
    const payload = { ...baseSettingsPayload(), transcription: { ...DEFAULT_TRANSCRIPTION_SETTINGS, language: "en" } };
    mockFetchRoutes({ "/api/settings": payload });
    window.history.replaceState(null, "", "/#/settings?section=voice");
    render(<App />);
    await act(async () => { await import("@/components/settings/SettingsView"); });
    const language = await screen.findByPlaceholderText("Auto");
    fireEvent.focus(language);
    fireEvent.change(language, { target: { value: "ja" } });
    fireEvent.click(screen.getByRole("button", { name: "Configure provider" }));
    expect(await screen.findByText("Model presets")).toBeInTheDocument();
    expect(window.location.hash).toBe("#/settings?section=models");
    expect(requestMutationSpy).not.toHaveBeenCalled();
    fireEvent.click(within(screen.getByRole("navigation", { name: "Settings sections" })).getByRole("button", { name: "Capabilities" }));
    fireEvent.click(within(screen.getByRole("region", { name: "Transcription" })).getByRole("button", { name: "Configure" }));
    expect(screen.getByPlaceholderText("Auto")).toHaveValue("ja");
  });

  it.each([true, false])("completes standalone channel drafts before leaving by history (saved=%s)", async (saved) => {
    const feature = {
      name: "email", display_name: "Email", type: "channel", webui: "webui/index.ts", enabled: false,
      configured: true, installed: true, requires_dependencies: false, ready: false, status: "not_enabled",
      install_supported: true, requires_restart: false, configured_fields: ["channels.email.imapHost"],
      config_values: { "channels.email.imapHost": "imap.example.test" },
      setup: { fields: [{ key: "channels.email.imapHost", field: "imapHost", kind: "string", required: true, choices: [] }], requirements: [] },
    };
    mockFetchRoutes({ "/api/settings": baseSettingsPayload(),
      "/api/settings/nanobot-features": { features: [feature], enabled_count: 0 } });
    let resolveSave!: (value: unknown) => void;
    let rejectSave!: (error: Error) => void;
    requestMutationSpy.mockImplementationOnce(() => new Promise((resolve, reject) => { resolveSave = resolve; rejectSave = reject; }));
    window.history.replaceState(null, "", "/#/channels");
    render(<App />);
    await act(async () => {
      await import("@/components/settings/SettingsView");
      await import("@/components/settings/channels/ChannelSetupPanel");
    });
    fireEvent.click(await screen.findByRole("button", { name: "View Email settings" }));
    const host = await screen.findByLabelText("IMAP host");
    fireEvent.focus(host);
    fireEvent.change(host, { target: { value: "imap.changed.test" } });
    act(() => {
      window.history.replaceState(null, "", "/#/new");
      window.dispatchEvent(new PopStateEvent("popstate"));
    });
    await waitFor(() => expect(requestMutationSpy).toHaveBeenCalledWith(
      "settings.channel.configure", expect.objectContaining({ name: "email", values: { "channels.email.imapHost": "imap.changed.test" } }), 150_000,
    ));
    expect(window.location.hash).toBe("#/channels");
    expect(host).toHaveValue("imap.changed.test");
    await act(async () => {
      if (saved) resolveSave({ name: "email", saved: true, saved_keys: ["channels.email.imapHost"] });
      else rejectSave(new Error("Save failed"));
    });
    if (saved) {
      await waitFor(() => expect(window.location.hash).toBe("#/new"));
      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    } else {
      expect(window.location.hash).toBe("#/channels");
      expect(host).toHaveValue("imap.changed.test");
      expect(await screen.findByText("Save failed")).toBeVisible();
    }
  });

  it("restores the settings section from the URL hash after a page reload", async () => {
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });
    window.history.replaceState(null, "", "/#/settings?section=voice");

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    expect(await screen.findByRole("dialog", { name: "Transcription" })).toBeInTheDocument();
    expect(window.location.hash).toBe("#/settings?section=voice");
  });

  it("keeps the backend timezone without writing settings on mount", async () => {
    const initialSettings = baseSettingsPayload();
    mockFetchRoutes({
      "/api/settings": initialSettings,
    });
    window.history.replaceState(null, "", "/#/settings?section=runtime");

    render(<App />);

    expect(await screen.findByText("UTC")).toBeInTheDocument();
    expect(
      requestMutationSpy.mock.calls.some(([action]) => action === "settings.agent.update"),
    ).toBe(false);
    expect(screen.queryByRole("heading", { name: "Region and timezone" })).not.toBeInTheDocument();
    expect(
      screen.queryByText("Used for schedules and time-aware replies."),
    ).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Save" })).not.toBeInTheDocument();
    expect(screen.queryByPlaceholderText("Search timezone")).not.toBeInTheDocument();
    const systemSection = screen.getByRole("heading", { name: "System" }).closest("section");
    expect(systemSection).not.toBeNull();
    const system = within(systemSection as HTMLElement);
    expect(system.getByText("Timezone")).toBeInTheDocument();
    expect(within(screen.getByRole("complementary")).getByRole("button", { name: "Restart" })).toBeInTheDocument();
    expect(
      system.queryByText("Restart nanobot to apply runtime changes."),
    ).not.toBeInTheDocument();
  });

  it("falls back to Overview for the retired Files settings URL", async () => {
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });
    window.history.replaceState(null, "", "/#/settings?section=files");

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    expect(
      await screen.findByRole("navigation", { name: "Settings sections" }),
    ).toBeInTheDocument();
    expect(screen.queryByRole("heading", { name: "Overview" })).not.toBeInTheDocument();
  });

  it("updates the URL hash when switching settings sections", async () => {
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "Settings" }));
    expect(
      await screen.findByRole("navigation", { name: "Settings sections" }),
    ).toBeInTheDocument();
    expect(window.location.hash).toBe("#/settings");

    const settingsNav = screen.getByRole("navigation", { name: "Settings sections" });
    const overviewButton = within(settingsNav).getByRole("button", {
      name: "Overview",
    });
    const modelsButton = within(settingsNav).getByRole("button", {
      name: "Models",
    });
    const settingsHighlight = within(settingsNav).getByTestId(
      "settings-selection-highlight",
    );

    expect(overviewButton).toHaveAttribute("aria-current", "page");
    expect(overviewButton).not.toHaveClass("bg-sidebar-accent");
    expect(overviewButton).toHaveClass("transition-[color,background-color]");
    expect(settingsHighlight).toHaveAttribute("data-active-id", "overview");

    fireEvent.click(modelsButton);

    expect(await screen.findByText("Model presets")).toBeInTheDocument();
    expect(screen.queryByRole("heading", { name: "Models" })).not.toBeInTheDocument();
    expect(window.location.hash).toBe("#/settings?section=models");
    expect(modelsButton).toHaveAttribute("aria-current", "page");
    expect(settingsHighlight).toHaveAttribute("data-active-id", "models");

    const voiceButton = within(settingsNav).getByRole("button", {
      name: "Capabilities",
    });
    fireEvent.click(voiceButton);

    expect(await screen.findByRole("switch", { name: "Transcription" })).toBeInTheDocument();
    expect(window.location.hash).toBe("#/settings?section=capabilities");
    expect(voiceButton).toHaveAttribute("aria-current", "page");
    expect(settingsHighlight).toHaveAttribute("data-active-id", "capabilities");
  });

  it("transitions between Apps and Skills without replacing the sidebar", async () => {
    mockFetchRoutes({
      "/api/settings": baseSettingsPayload(),
      "/api/settings/cli-apps": { apps: [], installed_count: 0, catalog_updated_at: "2026-04-18" },
      "/api/settings/mcp-presets": { presets: [], installed_count: 0 },
      "/api/webui/skills": { skills: [] },
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const appsButton = within(sidebar).getByRole("button", { name: "Apps" });

    fireEvent.click(appsButton);

    expect(await screen.findByRole("heading", { name: "Apps" })).toBeInTheDocument();
    expect(screen.queryByText("Add tools to nanobot, then @ them in chat.")).not.toBeInTheDocument();
    expect(screen.getByRole("navigation", { name: "Sidebar navigation" })).toBeInTheDocument();
    expect(screen.queryByRole("navigation", { name: "Settings sections" })).not.toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Apps" })).toHaveAttribute(
      "aria-current",
      "page",
    );
    expect(within(sidebar).getByTestId("actions-selection-highlight")).toHaveAttribute(
      "data-active-id",
      "utility:apps",
    );
    expect(within(sidebar).queryAllByRole("button", { current: "page" })).toHaveLength(1);
    expect(screen.getByTestId("settings-section-transition")).toHaveAttribute(
      "data-settings-section",
      "apps",
    );
    expect(screen.getByTestId("settings-section-transition")).toHaveClass(
      "animate-in",
      "fade-in-0",
      "slide-in-from-bottom-1",
      "duration-200",
      "motion-reduce:animate-none",
    );
    expect(document.title).toBe("Apps");

    fireEvent.click(within(sidebar).getByRole("button", { name: "Skills" }));

    expect(await screen.findByRole("heading", { name: "Skills" })).toBeInTheDocument();
    await waitFor(() => {
      expect(screen.getByTestId("settings-section-transition")).toHaveAttribute(
        "data-settings-section",
        "skills",
      );
    });
    expect(screen.getByRole("navigation", { name: "Sidebar navigation" })).toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Skills" })).toHaveAttribute(
      "aria-current",
      "page",
    );
    expect(within(sidebar).getByTestId("actions-selection-highlight")).toHaveAttribute(
      "data-active-id",
      "utility:skills",
    );
    expect(document.title).toBe("Skills");
  });

  it("returns from settings to the blank start page when no session was active", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "First chat",
      },
      {
        key: "websocket:chat-b",
        channel: "websocket",
        chatId: "chat-b",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        preview: "Second chat",
      },
    ];
    vi.stubGlobal(
      "fetch",
      vi.fn(async (input: RequestInfo | URL) => {
        if (String(input) === "/api/settings") {
          return {
            ok: true,
            status: 200,
            json: async () => ({
              agent: {
                model: "openai/gpt-4o",
                provider: "openai",
                resolved_provider: "openai",
                has_api_key: true,
                model_preset: "default",
                max_tokens: 8192,
                context_window_tokens: 65536,
                temperature: 0.1,
                reasoning_effort: null,
                timezone: "UTC",
                tool_hint_max_length: 40,
              },
              model_presets: [
                {
                  name: "default",
                  label: "Default",
                  active: true,
                  is_default: true,
                  model: "openai/gpt-4o",
                  provider: "openai",
                  max_tokens: 8192,
                  context_window_tokens: 65536,
                  temperature: 0.1,
                  reasoning_effort: null,
                },
              ],
              providers: [{ name: "openai", label: "OpenAI", configured: true }],
              web_search: {
                provider: "duckduckgo",
                api_key_hint: null,
                base_url: null,
                max_results: 5,
                timeout: 30,
                providers: [
                  { name: "duckduckgo", label: "DuckDuckGo", credential: "none" },
                  { name: "brave", label: "Brave Search", credential: "api_key" },
                ],
              },
              web: {
                enable: true,
                use_proxy: false,
                user_agent: null,
                search: { max_results: 5, timeout: 30 },
                fetch: { use_jina_reader: true },
              },
              image_generation: {
                enabled: false,
                provider: "openrouter",
                provider_configured: false,
                model: "openai/gpt-5.4-image-2",
                default_aspect_ratio: "1:1",
                default_image_size: "1K",
                max_images_per_turn: 4,
                save_dir: "generated",
                providers: [
                  {
                    name: "openrouter",
                    label: "OpenRouter",
                    configured: false,
                    api_key_hint: null,
                    api_base: null,
                    default_api_base: "https://openrouter.ai/api/v1",
                  },
                ],
              },
              runtime: {
                config_path: "/tmp/config.json",
                workspace_path: "/tmp/workspace",
                gateway_host: "127.0.0.1",
                gateway_port: 18790,
                heartbeat: {
                  enabled: true,
                  interval_s: 1800,
                },
                dream: {
                  schedule: "every 2h",
                },
                unified_session: false,
              },
              advanced: {
                restrict_to_workspace: false,
                webui_allow_local_service_access: true,
                webui_default_access_mode: "default",
                private_service_protection_enabled: true,
                ssrf_whitelist_count: 0,
                mcp_server_count: 0,
                exec_enabled: true,
                exec_sandbox: null,
                exec_path_prepend_set: false,
                exec_path_append_set: false,
              },
              requires_restart: false,
            }),
          };
        }
        return { ok: false, status: 404, json: async () => ({}) };
      }),
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    await waitFor(() => expect(document.title).toBe("nanobot"));

    fireEvent.click(within(sidebar).getByRole("button", { name: "Settings" }));
    expect(
      await screen.findByRole("navigation", { name: "Settings sections" }),
    ).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Back to chat" }));

    await waitFor(() => expect(document.title).toBe("nanobot"));
    expect(screen.getByText(HERO_GREETING_PATTERN)).toBeInTheDocument();
  });

  it("filters sessions in the centered search dialog", async () => {
    mockSessions = [
      {
        key: "websocket:chat-alpha",
        channel: "websocket",
        chatId: "chat-alpha",
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
        title: "Q2 roadmap",
        preview: "Project planning notes",
      },
      {
        key: "websocket:chat-beta",
        channel: "websocket",
        chatId: "chat-beta",
        createdAt: "2026-04-15T10:00:00Z",
        updatedAt: "2026-04-15T10:00:00Z",
        preview: "Travel ideas",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(sidebar).getByText("Q2 roadmap")).toBeInTheDocument();
    expect(within(sidebar).getByText("Travel ideas")).toBeInTheDocument();
    const newChatButton = within(sidebar).getByRole("button", { name: "New topic" });
    const searchButton = within(sidebar).getByRole("button", { name: "Search" });
    expect(
      searchButton.compareDocumentPosition(newChatButton) &
        Node.DOCUMENT_POSITION_FOLLOWING,
    ).toBeTruthy();

    fireEvent.click(searchButton);
    const dialog = await screen.findByRole("dialog", { name: "Search" });
    expect(dialog).toHaveClass("origin-center");
    expect(dialog.className).not.toContain("translate-x");
    expect(dialog.className).not.toContain("translate-y");
    expect(dialog.querySelector("kbd")).toBeNull();
    expect(within(dialog).getByText("Q2 roadmap")).toBeInTheDocument();
    expect(within(dialog).getByText("Travel ideas")).toBeInTheDocument();
    expect(within(dialog).queryByText("websocket")).not.toBeInTheDocument();
    expect(within(dialog).queryByText("#1")).not.toBeInTheDocument();

    fireEvent.change(within(dialog).getByRole("textbox", { name: "Search" }), {
      target: { value: "planning" },
    });

    expect(within(dialog).getByText("Q2 roadmap")).toBeInTheDocument();
    expect(within(dialog).queryByText("Travel ideas")).not.toBeInTheDocument();
    expect(within(sidebar).getByText("Travel ideas")).toBeInTheDocument();

    fireEvent.change(within(dialog).getByRole("textbox", { name: "Search" }), {
      target: { value: "road q2" },
    });

    expect(within(dialog).getByText("Q2 roadmap")).toBeInTheDocument();
    expect(within(dialog).queryByText("Travel ideas")).not.toBeInTheDocument();

    fireEvent.click(within(dialog).getByRole("button", { name: /Q2 roadmap/ }));

    await waitFor(() =>
      expect(screen.queryByRole("dialog", { name: "Search" })).not.toBeInTheDocument(),
    );
  });

  it("keeps panes adjacent and orders tabs by their latest updated pane", async () => {
    mockSessions = [
      {
        key: "websocket:alpha",
        channel: "websocket",
        chatId: "alpha",
        createdAt: "2026-08-01T10:00:00Z",
        updatedAt: "2026-08-01T10:00:00Z",
        title: "Alpha tab",
        preview: "",
      },
      {
        key: "websocket:alpha-child",
        channel: "websocket",
        chatId: "alpha-child",
        createdAt: "2026-08-05T10:00:00Z",
        updatedAt: "2026-08-05T10:00:00Z",
        title: "Alpha child",
        preview: "",
      },
      {
        key: "websocket:beta",
        channel: "websocket",
        chatId: "beta",
        createdAt: "2026-08-04T10:00:00Z",
        updatedAt: "2026-08-04T10:00:00Z",
        title: "Beta tab",
        preview: "",
      },
    ];
    vi.stubGlobal("fetch", vi.fn().mockImplementation(async (url: string | URL | Request) => {
      if (String(url) === "/api/webui/sidebar-state") {
        return {
          ok: true,
          json: async () => ({
            workbench: {
              version: 1,
              tabs: {
                "tab:websocket:alpha": {
                  explicit: true,
                  title: "Alpha tab",
                  paneKeys: ["websocket:alpha", "websocket:alpha-child"],
                  layout: "columns",
                },
                "tab:websocket:beta": {
                  explicit: false,
                  title: null,
                  paneKeys: ["websocket:beta"],
                  layout: "columns",
                },
              },
            },
          }),
        };
      }
      return { ok: false, status: 404 };
    }));

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const alphaTab = await within(sidebar).findByRole("button", { name: "Group: Alpha tab" });
    const betaTab = within(sidebar).getByRole("button", { name: "Beta tab" });
    expect(alphaTab.compareDocumentPosition(betaTab) & Node.DOCUMENT_POSITION_FOLLOWING)
      .toBeTruthy();

    const alphaGroup = alphaTab.closest("[data-sidebar-tab-group]") as HTMLElement;
    const alphaChild = within(alphaGroup).getByRole("button", { name: "Alpha child" });
    const alphaRoot = within(alphaGroup).getByRole("button", { name: "Alpha tab" });
    expect(alphaChild.compareDocumentPosition(alphaRoot) & Node.DOCUMENT_POSITION_FOLLOWING)
      .toBeTruthy();
  });

  it("uses one active pane without workbench editing controls on mobile", async () => {
    vi.stubGlobal("matchMedia", vi.fn((query: string) => ({
      matches: query.includes("max-width: 767px"),
      media: query,
      onchange: null,
      addListener: vi.fn(),
      removeListener: vi.fn(),
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      dispatchEvent: vi.fn(),
    })));
    mockSessions = [
      {
        key: "websocket:alpha",
        channel: "websocket",
        chatId: "alpha",
        createdAt: "2026-08-01T10:00:00Z",
        updatedAt: "2026-08-01T10:00:00Z",
        title: "Alpha tab",
        preview: "",
      },
      {
        key: "websocket:alpha-child",
        channel: "websocket",
        chatId: "alpha-child",
        createdAt: "2026-08-05T10:00:00Z",
        updatedAt: "2026-08-05T10:00:00Z",
        title: "Alpha child",
        preview: "",
      },
    ];
    window.history.replaceState(
      null,
      "",
      "/#/chat/websocket%3Aalpha-child",
    );
    vi.stubGlobal("fetch", vi.fn().mockImplementation(async (url: string | URL | Request) => {
      if (String(url) === "/api/webui/sidebar-state") {
        return {
          ok: true,
          json: async () => ({
            workbench: {
              version: 1,
              tabs: {
                "tab:websocket:alpha": {
                  explicit: true,
                  title: "Alpha tab",
                  paneKeys: ["websocket:alpha", "websocket:alpha-child"],
                  layout: "bsp",
                },
              },
            },
          }),
        };
      }
      return { ok: false, status: 404 };
    }));

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const grid = await screen.findByTestId("pane-grid");
    await waitFor(() => expect(Array.from(grid.children).map(
      (pane) => pane.getAttribute("aria-label"),
    )).toEqual(["Alpha child"]));
    expect(screen.queryByRole("button", { name: "Layout" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Add pane" })).not.toBeInTheDocument();

    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.pointerDown(within(sidebar).getByRole("button", {
      name: "Alpha child pane actions",
    }), { button: 0, ctrlKey: false });
    expect(await screen.findByRole("menuitem", { name: "Delete" })).toBeInTheDocument();
    expect(screen.queryByRole("menuitem", { name: "Remove" })).not.toBeInTheDocument();
    expect(screen.queryByRole("menuitem", { name: "Move to" })).not.toBeInTheDocument();
  });

  it("materializes a singleton tab without linking it to another pane", async () => {
    mockSessions = [
      {
        key: "websocket:solo",
        channel: "websocket",
        chatId: "solo",
        createdAt: "2026-08-05T10:00:00Z",
        updatedAt: "2026-08-05T10:00:00Z",
        title: "Solo pane",
        preview: "",
      },
      {
        key: "websocket:other",
        channel: "websocket",
        chatId: "other",
        createdAt: "2026-08-04T10:00:00Z",
        updatedAt: "2026-08-04T10:00:00Z",
        title: "Other pane",
        preview: "",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => {
      statusHandlers.forEach((handler) => handler("open"));
    });
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(sidebar).queryByRole("button", { name: "Group: Solo pane" }))
      .not.toBeInTheDocument();
    setSidebarStateSpy.mockClear();

    fireEvent.pointerDown(within(sidebar).getByRole("button", {
      name: "Topic actions for Solo pane",
    }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Create group" }));

    const tabButton = await within(sidebar).findByRole("button", {
      name: "Group: Solo pane",
    });
    const tabGroup = tabButton.closest("[data-sidebar-tab-group]") as HTMLElement;
    expect(within(tabGroup).getByRole("list", { name: "Panes in Solo pane" }))
      .toBeInTheDocument();
    expect(within(tabGroup).getAllByRole("button", { name: "Solo pane" }))
      .toHaveLength(1);
    expect(within(sidebar).queryByRole("button", { name: "Group: Other pane" }))
      .not.toBeInTheDocument();
    await waitFor(() => expect(setSidebarStateSpy).toHaveBeenCalledWith(
      expect.objectContaining({
        workbench: expect.objectContaining({
          tabs: expect.objectContaining({
            "tab:websocket:solo": expect.objectContaining({ explicit: true }),
          }),
        }),
      }),
    ));

    fireEvent.pointerDown(within(tabGroup).getByRole("button", {
      name: "Topic actions for Solo pane",
    }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Rename" }));

    const renameDialog = await screen.findByRole("dialog", { name: "Rename group" });
    expect(within(renameDialog).getByText("Give this group a name.")).toBeInTheDocument();
    expect(within(renameDialog).getByPlaceholderText("Group name")).toHaveValue("Solo pane");
  });

  it("restores a created pane group from gateway state after remount", async () => {
    mockSessions = [
      {
        key: "websocket:solo",
        channel: "websocket",
        chatId: "solo",
        createdAt: "2026-08-05T10:00:00Z",
        updatedAt: "2026-08-05T10:00:00Z",
        title: "Solo pane",
        preview: "",
      },
      {
        key: "websocket:other",
        channel: "websocket",
        chatId: "other",
        createdAt: "2026-08-04T10:00:00Z",
        updatedAt: "2026-08-04T10:00:00Z",
        title: "Other pane",
        preview: "",
      },
    ];
    let persistedState: SidebarStatePayload | null = null;
    vi.stubGlobal("fetch", vi.fn().mockImplementation(async (url: string | URL | Request) => {
      if (String(url) === "/api/webui/sidebar-state") {
        return {
          ok: true,
          json: async () => persistedState ?? {},
        };
      }
      return { ok: false, status: 404 };
    }));
    setSidebarStateSpy.mockImplementation(async (state: SidebarStatePayload) => {
      persistedState = state;
      return state;
    });

    const firstRender = render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    act(() => {
      statusHandlers.forEach((handler) => handler("open"));
    });
    const firstSidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.pointerDown(within(firstSidebar).getByRole("button", {
      name: "Topic actions for Solo pane",
    }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Create group" }));
    await waitFor(() => expect(persistedState?.workbench.tabs["tab:websocket:solo"])
      .toEqual(expect.objectContaining({ explicit: true })));

    firstRender.unmount();
    connectSpy.mockClear();

    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const secondSidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(await within(secondSidebar).findByRole("button", { name: "Group: Solo pane" }))
      .toBeInTheDocument();
  });

  it("keeps panes and layout scoped to the current topic tab", async () => {
    vi.stubGlobal("matchMedia", vi.fn((query: string) => ({
      matches: false,
      media: query,
      onchange: null,
      addListener: vi.fn(),
      removeListener: vi.fn(),
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      dispatchEvent: vi.fn(),
    })));
    createChatSpy.mockResolvedValueOnce("chat-pane");
    mockSessions = [
      {
        key: "websocket:chat-alpha",
        channel: "websocket",
        chatId: "chat-alpha",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        title: "Alpha",
        preview: "Alpha notes",
      },
      {
        key: "websocket:chat-beta",
        channel: "websocket",
        chatId: "chat-beta",
        createdAt: "2026-04-16T11:00:00Z",
        updatedAt: "2026-04-16T11:00:00Z",
        title: "Beta",
        preview: "Beta notes",
      },
    ];
    window.history.replaceState(
      null,
      "",
      "/#/chat/websocket%3Achat-alpha",
    );

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const grid = await screen.findByTestId("pane-grid");
    expect(Array.from(grid.children).map((pane) => pane.getAttribute("aria-label")))
      .toEqual(["Alpha"]);
    expect(screen.queryByRole("button", { name: "Layout" }))
      .not.toBeInTheDocument();
    const alphaInput = screen.getByRole("textbox", { name: "Message Alpha" });
    expect(screen.getByTestId("workbench-pane-websocket:chat-alpha")).toContainElement(alphaInput);
    fireEvent.change(alphaInput, { target: { value: "keep this Alpha draft" } });
    fireEvent.change(alphaInput.closest(".thread-composer-surface")!.querySelector('input[type="file"]')!, {
      target: { files: [new File(["notes"], "alpha-notes.txt", { type: "text/plain" })] },
    });
    expect(within(await screen.findByTestId("composer-chip")).getByRole("button", { name: "alpha-notes.txt" })).toBeVisible();

    fireEvent.click(screen.getByRole("button", { name: "Add pane" }));
    expect(screen.queryByRole("dialog", { name: "Search" })).not.toBeInTheDocument();
    await waitFor(() => expect(createChatSpy).toHaveBeenCalledTimes(1));

    await waitFor(() => expect(grid.children).toHaveLength(2));
    expect(screen.getByRole("button", { name: "Layout" })).toBeInTheDocument();
    expect(window.location.hash).toBe("#/chat/websocket%3Achat-pane");
    expect(Array.from(grid.children).map((pane) => pane.getAttribute("aria-label")))
      .toEqual(["Alpha", "New topic"]);

    const activeComposer = screen.getByTestId("active-pane-composer");
    const paneInput = within(activeComposer).getByRole("textbox", {
      name: "Message New topic",
    });
    expect(paneInput).toHaveClass("min-h-[50px]");
    fireEvent.change(paneInput, { target: { value: "route this to the new pane" } });
    fireEvent.keyDown(paneInput, { key: "Enter" });
    await waitFor(() => expect(sendMessageSpy).toHaveBeenCalled());
    expect(sendMessageSpy.mock.calls.at(-1)?.[0]).toBe("chat-pane");

    fireEvent.pointerDown(screen.getByRole("button", { name: "Layout" }), {
      button: 0,
      ctrlKey: false,
    });
    fireEvent.click(screen.getByRole("menuitemradio", { name: "Rows" }));
    expect(grid).toHaveAttribute("data-layout", "rows");

    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    const paneTopicButton = within(sidebar)
      .getAllByRole("button", { name: "New topic" })
      .find((button) => button.closest("[data-sidebar-pane]"));
    expect(paneTopicButton).toBeDefined();
    expect(paneTopicButton?.closest("[data-sidebar-pane]"))
      .toHaveAttribute("data-sidebar-pane", "websocket:chat-pane");
    fireEvent.click(within(sidebar).getByRole("button", { name: "Beta" }));
    await waitFor(() => {
      const nextGrid = screen.getByTestId("pane-grid");
      expect(Array.from(nextGrid.children).map((pane) => pane.getAttribute("aria-label")))
        .toEqual(["Beta"]);
      expect(nextGrid).toHaveAttribute("data-layout", "columns");
    });

    fireEvent.click(within(sidebar).getByRole("button", { name: "Alpha" }));
    await waitFor(() => {
      const restoredGrid = screen.getByTestId("pane-grid");
      expect(Array.from(restoredGrid.children).map((pane) => pane.getAttribute("aria-label")))
        .toEqual(["Alpha", "New topic"]);
      expect(restoredGrid).toHaveAttribute("data-layout", "rows");
    });

    const alphaGroupButton = within(sidebar).getByRole("button", {
      name: "Group: Alpha",
    });
    const alphaGroup = alphaGroupButton.closest("[data-sidebar-tab-group]") as HTMLElement;
    fireEvent.pointerDown(within(alphaGroup).getByLabelText("Topic actions for Alpha"), {
      button: 0,
      ctrlKey: false,
    });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Rename" }));
    const renameDialog = await screen.findByRole("dialog", { name: "Rename group" });
    fireEvent.change(within(renameDialog).getByPlaceholderText("Group name"), {
      target: { value: "Research" },
    });
    fireEvent.click(within(renameDialog).getByRole("button", { name: "Save" }));
    expect(await within(sidebar).findByRole("button", { name: "Group: Research" }))
      .toBeInTheDocument();

    fireEvent.pointerDown(within(sidebar).getByRole("button", {
      name: "New topic pane actions",
    }), { button: 0, ctrlKey: false });
    fireEvent.click(screen.getByRole("menuitem", {
      name: "Remove",
    }));
    await waitFor(() => expect(screen.getByTestId("pane-grid").children).toHaveLength(1));
    fireEvent.click(within(sidebar).getByRole("button", { name: "Alpha" }));
    const restoredInput = await screen.findByRole("textbox", { name: "Message Alpha" });
    expect(screen.getByTestId("workbench-pane-websocket:chat-alpha")).toContainElement(restoredInput);
    expect(restoredInput).toHaveValue("keep this Alpha draft");
    expect(within(await screen.findByTestId("composer-chip")).getByRole("button", { name: "alpha-notes.txt" })).toBeVisible();
    const researchGroup = within(sidebar).getByRole("button", {
      name: "Group: Research",
    }).closest("[data-sidebar-tab-group]") as HTMLElement;
    expect(within(researchGroup).getByRole("list", { name: "Panes in Research" }))
      .toBeInTheDocument();
    expect(within(researchGroup).getByRole("button", { name: "Alpha" }))
      .toBeInTheDocument();
    expect(within(sidebar).getAllByRole("button", { name: "New topic" })).toHaveLength(2);
  });

  it("keeps a named group and its remaining pane active after deleting a pane", async () => {
    mockSessions = [
      {
        key: "websocket:new-pane",
        channel: "websocket",
        chatId: "new-pane",
        createdAt: "2026-08-05T12:00:00Z",
        updatedAt: "2026-08-05T12:00:00Z",
        title: "New topic",
        preview: "",
      },
      {
        key: "websocket:unrelated",
        channel: "websocket",
        chatId: "unrelated",
        createdAt: "2026-08-05T11:00:00Z",
        updatedAt: "2026-08-05T11:00:00Z",
        title: "Unrelated",
        preview: "",
      },
      {
        key: "websocket:alpha",
        channel: "websocket",
        chatId: "alpha",
        createdAt: "2026-08-05T10:00:00Z",
        updatedAt: "2026-08-05T10:00:00Z",
        title: "Alpha",
        preview: "",
      },
    ];
    window.history.replaceState(null, "", "/#/chat/websocket%3Anew-pane");
    vi.stubGlobal("fetch", vi.fn().mockImplementation(async (url: string | URL | Request) => {
      if (String(url) === "/api/webui/sidebar-state") {
        return {
          ok: true,
          json: async () => ({
            workbench: {
              version: 1,
              tabs: {
                "tab:websocket:alpha": {
                  explicit: false,
                  title: "Research",
                  paneKeys: ["websocket:alpha", "websocket:new-pane"],
                  layoutPaneKeys: ["websocket:alpha", "websocket:new-pane"],
                  layout: "columns",
                  splitRatios: [],
                },
              },
            },
          }),
        };
      }
      return { ok: false, status: 404 };
    }));

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(await within(sidebar).findByRole("button", { name: "Group: Research" }))
      .toBeInTheDocument();
    fireEvent.pointerDown(within(sidebar).getByRole("button", {
      name: "New topic pane actions",
    }), { button: 0, ctrlKey: false });
    fireEvent.click(await screen.findByRole("menuitem", { name: "Delete" }));
    expect(await screen.findByText("Delete this topic?")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Delete" }));

    await waitFor(() => expect(deleteChatSpy).toHaveBeenCalledWith("websocket:new-pane"));
    await waitFor(() => expect(window.location.hash).toBe("#/chat/websocket%3Aalpha"));
    expect(within(sidebar).getByRole("button", { name: "Group: Research" }))
      .toBeInTheDocument();
    expect(screen.getByTestId("pane-grid").children).toHaveLength(1);
    expect(screen.getByTestId("pane-grid").firstElementChild)
      .toHaveAttribute("aria-label", "Alpha");
  }, 15_000);

  it("opens search from the keyboard shortcut", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Existing chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.keyDown(window, { key: "k", metaKey: true });

    const dialog = await screen.findByRole("dialog", { name: "Search" });
    expect(within(dialog).queryByText("Global actions")).not.toBeInTheDocument();
    expect(within(dialog).getByText("Existing chat")).toBeInTheDocument();

    const textbox = within(dialog).getByRole("textbox", { name: "Search" });
    fireEvent.change(textbox, { target: { value: "missing" } });
    expect(within(dialog).queryByText("Existing chat")).not.toBeInTheDocument();

    fireEvent.change(textbox, { target: { value: "existing" } });
    expect(within(dialog).getByText("Existing chat")).toBeInTheDocument();

    fireEvent.keyDown(textbox, { key: "Enter" });
    await waitFor(() =>
      expect(screen.queryByRole("dialog", { name: "Search" })).not.toBeInTheDocument(),
    );
    expect(createChatSpy).not.toHaveBeenCalled();
  });

  it.each([
    ["apps", "1", "Digit1", true],
    ["skills", "2", "Digit2", true],
    ["automations", "3", "Digit3", true],
    ["settings", ",", "Comma", false],
  ])("opens %s using its sidebar shortcut", async (route, key, code, shiftKey) => {
    mockFetchRoutes({ "/api/settings": baseSettingsPayload() });
    render(<App />);
    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.keyDown(window, { key, code, shiftKey, ctrlKey: true });
    await waitFor(() => expect(window.location.hash).toContain("#/" + route));
  });

  it.each([
    ["Command", { metaKey: true }],
    ["Control", { ctrlKey: true }],
  ])("starts a new chat from the %s keyboard shortcut", async (_label, modifier) => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Existing chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.keyDown(window, { key: "O", shiftKey: true, ...modifier });

    expect(window.location.hash).toBe("#/new");
  });

  it("closes search when starting a new chat from the keyboard shortcut", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Existing chat",
      },
    ];

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    fireEvent.keyDown(window, { key: "k", metaKey: true });
    expect(await screen.findByRole("dialog", { name: "Search" })).toBeInTheDocument();

    fireEvent.keyDown(window, { key: "O", shiftKey: true, metaKey: true });

    await waitFor(() =>
      expect(screen.queryByRole("dialog", { name: "Search" })).not.toBeInTheDocument(),
    );
    expect(window.location.hash).toBe("#/new");
  });

  it("exposes the new chat keyboard shortcut in the sidebar tooltip", async () => {
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });

    const newChatButton = within(sidebar).getByRole("button", { name: "New topic" });
    expect(newChatButton).toHaveTextContent("");
    await userEvent.setup().hover(newChatButton);
    const tooltip = await screen.findByRole("tooltip");
    expect(tooltip).toHaveTextContent("New topic");
    expect(tooltip.querySelector("kbd")).toHaveTextContent("Ctrl+Shift+O");
    expect(newChatButton).toHaveAttribute(
      "aria-keyshortcuts",
      "Meta+Shift+O Control+Shift+O",
    );
  });

  it("uses macOS shortcut glyphs in the sidebar tooltip", async () => {
    setNavigatorPlatform("MacIntel");
    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });

    await userEvent.setup().hover(within(sidebar).getByRole("button", { name: "New topic" }));
    const tooltip = await screen.findByRole("tooltip");
    expect(tooltip).toHaveTextContent("New topic");
    expect(tooltip.querySelector("kbd")).toHaveTextContent("⌘⇧O");
  });

  it("keeps large sidebars light while search still covers every chat", async () => {
    mockSessions = Array.from({ length: 170 }, (_, index) => {
      const chatId = `chat-${index}`;
      return {
        key: `websocket:${chatId}`,
        channel: "websocket" as const,
        chatId,
        createdAt: new Date(Date.UTC(2026, 3, 16, 12, 0 - index)).toISOString(),
        updatedAt: new Date(Date.UTC(2026, 3, 16, 12, 0 - index)).toISOString(),
        title: index === 169 ? "Hidden target" : `Bulk chat ${index}`,
        preview: "",
      };
    });

    render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());
    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    await waitFor(() =>
      expect(within(sidebar).getByRole("button", { name: "Bulk chat 0" })).toBeInTheDocument(),
    );
    expect(within(sidebar).queryByText("Hidden target")).not.toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Show 10 more" })).toBeInTheDocument();

    fireEvent.click(within(sidebar).getByRole("button", { name: "Search" }));
    const dialog = await screen.findByRole("dialog", { name: "Search" });
    fireEvent.change(within(dialog).getByRole("textbox", { name: "Search" }), {
      target: { value: "hidden" },
    });
    expect(within(dialog).getByText("Hidden target")).toBeInTheDocument();
  });

  it("opens a blank start page without creating an empty chat", async () => {
    mockSessions = [
      {
        key: "websocket:chat-a",
        channel: "websocket",
        chatId: "chat-a",
        createdAt: "2026-04-16T10:00:00Z",
        updatedAt: "2026-04-16T10:00:00Z",
        preview: "Existing chat",
      },
    ];

    const matchMedia = vi.fn().mockImplementation((query: string) => ({
      matches: query.includes("1024px"),
      media: query,
      onchange: null,
      addListener: vi.fn(),
      removeListener: vi.fn(),
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      dispatchEvent: vi.fn(),
    }));
    vi.stubGlobal("matchMedia", matchMedia);

    const { container } = render(<App />);

    await waitFor(() => expect(connectSpy).toHaveBeenCalled());

    fireEvent.click(await screen.findByRole("button", { name: "Toggle theme from header" }));
    expect(toggleThemeSpy).toHaveBeenCalledTimes(1);

    fireEvent.keyDown(screen.getByRole("separator", { name: "Resize sidebar" }), { key: "Enter" });
    const sidebarAside = container.querySelector("aside.lg\\:block") as HTMLElement;
    await waitFor(() => expect(sidebarAside.style.width).toBe("56px"));

    expect(screen.queryByRole("button", { name: "Start a new topic" })).not.toBeInTheDocument();
    const rail = screen.getByRole("navigation", { name: "Sidebar navigation" });
    expect(within(rail).getByRole("button", { name: "New topic" })).toBeInTheDocument();
    expect(within(rail).getByRole("button", { name: "Search" })).toBeInTheDocument();
    expect(within(rail).queryByRole("button", { name: "View" })).not.toBeInTheDocument();
    expect(within(rail).queryByText("Existing chat")).not.toBeInTheDocument();

    fireEvent.click(within(rail).getByRole("button", { name: "Toggle sidebar" }));
    await waitFor(() => expect(sidebarAside.style.width).toBe("272px"));

    const sidebar = screen.getByRole("navigation", { name: "Sidebar navigation" });
    fireEvent.click(within(sidebar).getByRole("button", { name: "New topic" }));
    expect(createChatSpy).not.toHaveBeenCalled();
    expect(screen.getByText(HERO_GREETING_PATTERN)).toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Start a new topic" })).not.toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Toggle theme from header" })).toBeInTheDocument();
    expect(within(sidebar).getByRole("button", { name: "Settings" })).toBeInTheDocument();

    expect(within(sidebar).getByText("Existing chat")).toBeInTheDocument();
  });

  it("refreshes the bootstrap token before REST settings auth expires", async () => {
    vi.useFakeTimers();
    vi.mocked(fetchBootstrap)
      .mockResolvedValueOnce({
        token: "tok-1",
        api_token: "api-tok-1",
        ws_path: "/",
        expires_in: 30,
      })
      .mockResolvedValueOnce({
        token: "tok-2",
        api_token: "api-tok-2",
        ws_path: "/",
        expires_in: 300,
      });
    vi.mocked(deriveWsUrl).mockImplementation(
      (_wsPath, token) => `ws://test?token=${token}`,
    );

    const { unmount } = render(<App />);
    await act(async () => {});

    expect(connectSpy).toHaveBeenCalled();
    expect(fetchBootstrap).toHaveBeenCalledTimes(1);

    await act(async () => {
      await vi.advanceTimersByTimeAsync(15_000);
    });

    expect(fetchBootstrap).toHaveBeenCalledTimes(2);
    expect(updateUrlSpy).toHaveBeenCalledWith("ws://test?token=tok-2");
    unmount();
  });

  it("refreshes pairing immediately on notices and ready, only while visible", async () => {
    vi.useFakeTimers();
    let requests: Record<string, unknown>[] = [];
    mockFetchRoutes({ "/api/settings/pairing": () => ({ requests }) });
    const { unmount } = render(<App />);
    await act(async () => {});
    const pairingReads = () => vi.mocked(fetch).mock.calls.filter(([input]) => String(input) === "/api/settings/pairing").length;
    expect(pairingReads()).toBe(1);
    await act(async () => { await vi.advanceTimersByTimeAsync(1_000); });
    requests = [{ code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "sent" }];
    await act(async () => { for (const handler of pairingChangeHandlers) handler(); });
    expect(screen.getByRole("dialog", { name: "Pair account" })).toBeVisible();
    expect(pairingReads()).toBe(2);
    requests = [];
    await act(async () => { await vi.advanceTimersByTimeAsync(5_000); });
    expect(pairingReads()).toBe(3);
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();

    const visibilityDescriptor = Object.getOwnPropertyDescriptor(document, "visibilityState");
    const setVisibility = (state: DocumentVisibilityState) => {
      Object.defineProperty(document, "visibilityState", { configurable: true, value: state });
      document.dispatchEvent(new Event("visibilitychange"));
    };
    try {
      act(() => setVisibility("hidden"));
      requests = [];
      await act(async () => {
        for (const handler of pairingChangeHandlers) handler();
        for (const handler of readyHandlers) handler();
        await vi.advanceTimersByTimeAsync(15_000);
      });
      expect(pairingReads()).toBe(3);
      await act(async () => setVisibility("visible"));
      expect(pairingReads()).toBe(4);
      expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();

      requests = [{ code: "IJKL-MNOP", channel: "feishu", sender_id: "bob", delivery_status: "sent" }];
      await act(async () => { for (const handler of readyHandlers) handler(); });
      expect(screen.getByRole("dialog", { name: "Pair account" })).toBeVisible();
      expect(pairingReads()).toBe(5);
      unmount();
      await act(async () => {
        for (const handler of pairingChangeHandlers) handler();
        for (const handler of readyHandlers) handler();
        await vi.advanceTimersByTimeAsync(15_000);
      });
      expect(pairingReads()).toBe(5);
    } finally {
      if (visibilityDescriptor) Object.defineProperty(document, "visibilityState", visibilityDescriptor);
      else Reflect.deleteProperty(document, "visibilityState");
    }
  });

  it("polls for cross-process pairing changes and expiry without a notice", async () => {
    vi.useFakeTimers();
    let requests: Record<string, unknown>[] = [];
    mockFetchRoutes({ "/api/settings/pairing": () => ({ requests }) });
    render(<App />);
    await act(async () => {});
    requests = [{ code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", expires_in_seconds: 5 }];
    await act(async () => { await vi.advanceTimersByTimeAsync(14_999); });
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();
    await act(async () => { await vi.advanceTimersByTimeAsync(1); });
    expect(screen.getByRole("dialog", { name: "Pair account" })).toHaveTextContent("Code expires 5s.");
    requests = [];
    await act(async () => { await vi.advanceTimersByTimeAsync(4_999); });
    expect(screen.getByRole("dialog", { name: "Pair account" })).toBeVisible();
    await act(async () => { await vi.advanceTimersByTimeAsync(1); });
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();
  });

  it.each([false, true])("coalesces notices during an older pairing read and pauses while hidden (%s)", async (hide) => {
    let finishOldRead!: (value: unknown) => void;
    const oldSnapshot = new Promise((resolve) => { finishOldRead = resolve; });
    let reads = 0;
    mockFetchRoutes({ "/api/settings/pairing": () => ++reads === 1 ? oldSnapshot : { requests: [{
      code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "sent",
    }] } });
    const visibilityDescriptor = Object.getOwnPropertyDescriptor(document, "visibilityState");
    const setVisibility = (state: DocumentVisibilityState) => {
      Object.defineProperty(document, "visibilityState", { configurable: true, value: state });
      document.dispatchEvent(new Event("visibilitychange"));
    };
    const { unmount } = render(<App />);
    try {
      await waitFor(() => expect(reads).toBe(1));
      act(() => {
        for (let notice = 0; notice < 3; notice += 1) {
          for (const handler of pairingChangeHandlers) handler();
        }
        if (hide) setVisibility("hidden");
      });
      expect(reads).toBe(1);
      await act(async () => { finishOldRead({ requests: [] }); });
      if (hide) {
        expect(reads).toBe(1);
        await act(async () => setVisibility("visible"));
      }
      expect(screen.getByRole("dialog", { name: "Pair account" })).toBeVisible();
      expect(reads).toBe(2);
    } finally {
      unmount();
      if (visibilityDescriptor) Object.defineProperty(document, "visibilityState", visibilityDescriptor);
      else Reflect.deleteProperty(document, "visibilityState");
    }
  });

  it.each(["success", "failure"])("reconciles a late pairing mutation after a notice shows a newer request (%s)", async (outcome) => {
    let requests = [{
      code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", expires_in_seconds: 120,
    }];
    mockFetchRoutes({ "/api/settings/pairing": () => ({ requests }) });
    let reply!: (payload: unknown) => void;
    let fail!: (error: Error) => void;
    requestMutationSpy.mockImplementationOnce(() => new Promise((resolve, reject) => { reply = resolve; fail = reject; }));
    render(<App />);
    const popup = await screen.findByRole("dialog", { name: "Pair account" });
    fireEvent.change(within(popup).getByRole("textbox", { name: "Pairing code" }), {
      target: { value: "ABCD-EFGH" },
    });
    expect(requestMutationSpy).toHaveBeenCalledWith("settings.pairing.approve", { code: "ABCD-EFGH" }, expect.any(Number));
    requests = [{
      code: "IJKL-MNOP", channel: "feishu.second", sender_id: "bob", expires_in_seconds: 240,
    }];
    await act(async () => { for (const handler of pairingChangeHandlers) handler(); });
    expect(popup).toHaveTextContent("Code expires 4 min.");
    await act(async () => {
      if (outcome === "success") reply({ requests: [] });
      else fail(new Error("Approval unavailable"));
    });
    expect(screen.getByRole("dialog", { name: "Pair account" })).toHaveTextContent("Code expires 4 min.");
    expect(vi.mocked(fetch).mock.calls.filter(([input]) => String(input) === "/api/settings/pairing")).toHaveLength(3);
    expect(requestMutationSpy).toHaveBeenCalledTimes(1);
  });

  it.each(["sending", "failed"])("explains an undelivered pairing reply (%s) without empty code slots", async (delivery_status) => {
    mockFetchRoutes({ "/api/settings/pairing": { requests: [{
      code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status,
    }] } });
    render(<App />);
    const popup = await screen.findByRole("dialog", { name: "Pair account" });
    expect(within(popup).getByText("Already received a code?").closest("details")).not.toHaveAttribute("open");
    expect(within(popup).getByText(/another private message to retry/)).toBeVisible();
    if (delivery_status === "failed") expect(within(popup).getByRole("alert")).toBeVisible();
    fireEvent.click(within(popup).getByText("Already received a code?"));
    expect(within(popup).getByRole("textbox", { name: "Pairing code" })).toBeEnabled();
    expect(requestMutationSpy).not.toHaveBeenCalledWith("settings.pairing.approve", expect.anything(), expect.anything());
  });

  it.each([undefined, "sent"])("keeps legacy/delivered pairing usable behind a failed request (%s)", async (delivery_status) => {
    mockFetchRoutes({ "/api/settings/pairing": { requests: [
      { code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "failed" },
      { code: "IJKL-MNOP", channel: "feishu.second", sender_id: "bob", delivery_status },
    ] } });
    render(<App />);
    const popup = await screen.findByRole("dialog", { name: "Pair account" });
    expect(within(popup).getByRole("textbox", { name: "Pairing code" })).toBeEnabled();
    expect(within(popup).queryByRole("alert")).not.toBeInTheDocument();
    expect(within(popup).getByText("2 pending")).toBeVisible();
  });

  it("shows a dismissed pairing request again when its snooze expires", async () => {
    vi.useFakeTimers();
    mockFetchRoutes({ "/api/settings/pairing": { requests: [{
      code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "sent",
    }] } });
    render(<App />);
    await act(async () => {});
    fireEvent.click(within(screen.getByRole("dialog", { name: "Pair account" }))
      .getByRole("button", { name: "Close" }));
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();

    await act(async () => { await vi.advanceTimersByTimeAsync(29_999); });
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();
    await act(async () => { await vi.advanceTimersByTimeAsync(1); });
    const popup = screen.getByRole("dialog", { name: "Pair account" });
    expect(popup).toBeVisible();
    expect(within(popup).getByRole("textbox", { name: "Pairing code" })).toBeEnabled();
  });

  it("shows a recovered pairing reply even after its failure notice was dismissed", async () => {
    vi.useFakeTimers();
    let delivery_status = "failed";
    mockFetchRoutes({ "/api/settings/pairing": () => ({ requests: [{
      code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status,
    }] }) });
    render(<App />);
    await act(async () => {});
    fireEvent.click(within(screen.getByRole("dialog", { name: "Pair account" }))
      .getByRole("button", { name: "Close" }));
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();
    await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();

    delivery_status = "sent";
    await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
    const popup = screen.getByRole("dialog", { name: "Pair account" });
    expect(within(popup).getByRole("textbox", { name: "Pairing code" })).toBeEnabled();
    expect(within(popup).queryByRole("alert")).not.toBeInTheDocument();
    expect(requestMutationSpy).not.toHaveBeenCalled();
  });

  it("keeps a failed pairing approval idle until the user retries", async () => {
    vi.useFakeTimers();
    let requests = [{ code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "sent" }];
    mockFetchRoutes({ "/api/settings/pairing": () => ({ requests }) });
    requestMutationSpy
      .mockRejectedValueOnce(new Error("Approval unavailable"))
      // Bound the old automatic retry loop while reproducing it.
      .mockImplementation(() => new Promise(() => {}));
    render(<App />);
    await act(async () => {});
    const popup = screen.getByRole("dialog", { name: "Pair account" });
    fireEvent.change(within(popup).getByRole("textbox", { name: "Pairing code" }), {
      target: { value: "ABCD-EFGH" },
    });
    await act(async () => {});
    await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
    expect(requestMutationSpy).toHaveBeenCalledTimes(1);
    expect(within(popup).getByText("Approval unavailable")).toBeVisible();
    expect(within(popup).getByRole("textbox", { name: "Pairing code" })).toBeEnabled();

    requests = [];
    requestMutationSpy.mockResolvedValueOnce({ requests });
    fireEvent.click(within(popup).getByRole("button", { name: "Retry" }));
    await act(async () => {});
    expect(requestMutationSpy).toHaveBeenCalledTimes(2);
    expect(screen.queryByRole("dialog", { name: "Pair account" })).not.toBeInTheDocument();
  });

  it("reuses an in-flight pairing poll then reads current requests on visible return", async () => {
    let resolvePairing!: (response: Response) => void;
    const pendingPairing = new Promise<Response>((resolve) => {
      resolvePairing = resolve;
    });
    let reads = 0;
    const fetchMock = vi.fn((input: RequestInfo | URL) => {
      if (String(input) !== "/api/settings/pairing") return Promise.resolve({ ok: false, status: 404 } as Response);
      return ++reads === 1 ? pendingPairing : Promise.resolve(jsonResponse({ requests: [{
        code: "ABCD-EFGH", channel: "feishu", sender_id: "alice", delivery_status: "sent",
      }] }));
    });
    vi.stubGlobal("fetch", fetchMock);
    const visibilityDescriptor = Object.getOwnPropertyDescriptor(document, "visibilityState");

    const setVisibility = (state: DocumentVisibilityState) => {
      Object.defineProperty(document, "visibilityState", {
        configurable: true,
        value: state,
      });
      document.dispatchEvent(new Event("visibilitychange"));
    };

    try {
      render(<App />);
      await waitFor(() => {
        expect(fetchMock.mock.calls.filter(([input]) => (
          String(input) === "/api/settings/pairing"
        ))).toHaveLength(1);
      });

      act(() => setVisibility("hidden"));
      act(() => setVisibility("visible"));

      expect(fetchMock.mock.calls.filter(([input]) => (
        String(input) === "/api/settings/pairing"
      ))).toHaveLength(1);
      await act(async () => {
        resolvePairing(jsonResponse({ requests: [] }));
        await pendingPairing;
      });
      expect(screen.getByRole("dialog", { name: "Pair account" })).toBeVisible();
      expect(reads).toBe(2);
    } finally {
      if (visibilityDescriptor) {
        Object.defineProperty(document, "visibilityState", visibilityDescriptor);
      } else {
        Reflect.deleteProperty(document, "visibilityState");
      }
    }
  });
});