Skip to content

Your lightweight open-source personal agent.

182 KB
Raw Blame
import { act, createEvent, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { afterEach, describe, expect, it, vi } from "vitest";

import { ThreadComposer } from "@/components/thread/ThreadComposer";
import { ComposerUsagePopover } from "@/components/thread/ComposerUsagePopover";
import { ComposerDraftStore } from "@/lib/composer-draft";
import { encodeImage } from "@/lib/imageEncode";
import { SESSION_DRAG_TYPE } from "@/lib/session-drag";
import type { ChatSummary, CliAppInfo, McpPresetInfo, SlashCommand, WorkspaceScopePayload } from "@/lib/types";

function workspacePickerProps(scope: WorkspaceScopePayload) {
  const resolvePath = (path: string) => path.startsWith("~/") ? `/Users/test/${path.slice(2)}` : path;
  return {
    onLoadWorkspaceProjects: async () => ({
      schema_version: 1,
      default_access_mode: "default" as const,
      default_scope: scope,
      recent_projects: [],
      favorite_projects: [],
      controls: { can_change_project: true },
    }),
    onBrowseWorkspaceDirectories: async (path: string) => ({
      path: resolvePath(path), parent: null, entries: [], partial: false,
      truncated: false, host: "test-host", platform: "Linux",
    }),
    onResolveWorkspaceProject: async (path: string) => ({
      path: resolvePath(path), name: path.replace(/\\/g, "/").split("/").filter(Boolean).pop() || path,
    }),
    onFavoriteWorkspaceProject: async () => [],
  };
}

vi.mock("@/lib/imageEncode", () => ({
  encodeImage: vi.fn(async (file: File) => ({
    ok: true,
    dataUrl: `data:${file.type || "image/png"};base64,aW1hZ2U=`,
    bytes: Math.max(1, file.size),
    normalized: false,
  })),
}));

const COMMANDS: SlashCommand[] = [
  {
    command: "/stop",
    title: "Stop current task",
    description: "Cancel the active agent turn.",
    icon: "square",
    lifecycle: "stop_active_turn",
    acceptsArgs: false,
  },
  {
    command: "/history",
    title: "Show conversation history",
    description: "Print the last N persisted messages.",
    icon: "history",
    argHint: "[n]",
    lifecycle: "side_channel",
    acceptsArgs: true,
  },
];

const CLI_APPS: CliAppInfo[] = [
  {
    name: "gimp",
    display_name: "GIMP",
    category: "image",
    description: "Image editing",
    requires: "",
    source: "harness",
    entry_point: "cli-anything-gimp",
    install_supported: true,
    installed: true,
    available: true,
    status: "installed",
    logo_url: "https://example.invalid/gimp.svg",
    brand_color: "#5C5543",
    skill_installed: true,
  },
  {
    name: "blender",
    display_name: "Blender",
    category: "3d",
    description: "3D creation",
    requires: "",
    source: "harness",
    entry_point: "cli-anything-blender",
    install_supported: true,
    installed: true,
    available: true,
    status: "installed",
    logo_url: null,
    brand_color: "#E87D0D",
    skill_installed: true,
  },
  {
    name: "krita",
    display_name: "Krita",
    category: "image",
    description: "Painting",
    requires: "",
    source: "harness",
    entry_point: "cli-anything-krita",
    install_supported: true,
    installed: false,
    available: false,
    status: "not_installed",
    logo_url: null,
    brand_color: "#3BABFF",
    skill_installed: false,
  },
];

const MCP_PRESETS: McpPresetInfo[] = [
  {
    name: "browserbase",
    display_name: "Browserbase",
    category: "browser",
    description: "Cloud browser automation",
    docs_url: "https://docs.browserbase.com",
    transport: "streamableHttp",
    requires: "Browserbase API key",
    note: "",
    install_supported: true,
    installed: true,
    configured: true,
    available: true,
    status: "configured",
    logo_url: "https://example.invalid/browserbase.svg",
    brand_color: "#111827",
    required_fields: [],
    connection_summary: "https://mcp.browserbase.com/mcp",
  },
  {
    name: "figma",
    display_name: "Figma",
    category: "design",
    description: "Design context",
    docs_url: "https://figma.com",
    transport: "streamableHttp",
    requires: "Figma local app",
    note: "",
    install_supported: true,
    installed: true,
    configured: false,
    available: false,
    status: "missing_credentials",
    logo_url: null,
    brand_color: "#F24E1E",
    required_fields: [],
    connection_summary: "",
  },
];

function session(chatId: string, title: string, preview = "", handleName = title): ChatSummary {
  const key = `websocket:${chatId}`;
  const handleId = Array.from(chatId)
    .map((character) => character.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000")
    .join("")
    .padEnd(32, "0")
    .slice(0, 32);
  return {
    key,
    channel: "websocket",
    chatId,
    createdAt: null,
    updatedAt: null,
    title,
    preview,
    handle: {
      id: `handle_${handleId}`,
      name: handleName,
    },
  };
}

const ORIGINAL_INNER_HEIGHT = window.innerHeight;
const ORIGINAL_MEDIA_DEVICES = navigator.mediaDevices;

function mockBlobUrls() {
  Object.defineProperty(URL, "createObjectURL", {
    configurable: true,
    value: vi.fn(() => "blob:composer-test"),
  });
  Object.defineProperty(URL, "revokeObjectURL", {
    configurable: true,
    value: vi.fn(),
  });
}

function stubVisualViewport({
  height,
  offsetTop = 0,
}: {
  height: number;
  offsetTop?: number;
}) {
  const target = new EventTarget();
  vi.stubGlobal("visualViewport", {
    width: 390,
    height,
    offsetTop,
    offsetLeft: 0,
    pageTop: offsetTop,
    pageLeft: 0,
    scale: 1,
    addEventListener: target.addEventListener.bind(target),
    removeEventListener: target.removeEventListener.bind(target),
    dispatchEvent: target.dispatchEvent.bind(target),
  } as unknown as VisualViewport);
}

afterEach(() => {
  vi.restoreAllMocks();
  vi.unstubAllGlobals();
  vi.useRealTimers();
  Reflect.deleteProperty(window, "nanobotHost");
  if (ORIGINAL_MEDIA_DEVICES) {
    Object.defineProperty(navigator, "mediaDevices", {
      configurable: true,
      value: ORIGINAL_MEDIA_DEVICES,
    });
  } else {
    Reflect.deleteProperty(navigator, "mediaDevices");
  }
  window.localStorage.clear();
  Object.defineProperty(window, "innerHeight", {
    value: ORIGINAL_INNER_HEIGHT,
    configurable: true,
  });
});

function rect(init: Partial<DOMRect>): DOMRect {
  const top = init.top ?? 0;
  const left = init.left ?? 0;
  const width = init.width ?? 0;
  const height = init.height ?? 0;
  return {
    x: init.x ?? left,
    y: init.y ?? top,
    top,
    left,
    width,
    height,
    right: init.right ?? left + width,
    bottom: init.bottom ?? top + height,
    toJSON: () => ({}),
  };
}

function mockVoiceRecorder(blob = new Blob(["voice"], { type: "audio/webm" })) {
  const stopTrack = vi.fn();
  const getUserMedia = vi.fn(async () => ({
    getTracks: () => [{ stop: stopTrack }],
  }));
  Object.defineProperty(navigator, "mediaDevices", {
    configurable: true,
    value: { getUserMedia },
  });

  class FakeMediaRecorder {
    static isTypeSupported = vi.fn((type: string) => type === "audio/webm");

    state: RecordingState = "inactive";
    mimeType = blob.type;
    ondataavailable: ((event: BlobEvent) => void) | null = null;
    onstop: (() => void) | null = null;

    start() {
      this.state = "recording";
    }

    stop() {
      this.state = "inactive";
      this.ondataavailable?.({ data: blob } as BlobEvent);
      this.onstop?.();
    }
  }

  vi.stubGlobal("MediaRecorder", FakeMediaRecorder);
  return { getUserMedia, stopTrack };
}

function mockVoiceAudioInput(
  sample = 128,
  state: AudioContextState = "running",
  decodedChannels?: Float32Array[],
) {
  const decodeAudioDataMock = vi.fn(async () => {
    if (!decodedChannels) throw new Error("decodeAudioData not mocked");
    return {
      numberOfChannels: decodedChannels.length,
      sampleRate: 16_000,
      getChannelData: (channel: number) => decodedChannels[channel],
    } as AudioBuffer;
  });

  class FakeAudioContext {
    state = state;

    createMediaStreamSource() {
      return { connect: vi.fn(), disconnect: vi.fn() };
    }

    createAnalyser() {
      return {
        fftSize: 256,
        smoothingTimeConstant: 0,
        disconnect: vi.fn(),
        getByteTimeDomainData: (data: Uint8Array) => data.fill(sample),
      };
    }

    close = vi.fn(async () => undefined);
    decodeAudioData = decodeAudioDataMock;
    resume = vi.fn(async () => undefined);
  }

  vi.stubGlobal("AudioContext", FakeAudioContext);
  vi.spyOn(window, "requestAnimationFrame").mockImplementation((callback) =>
    window.setTimeout(() => callback(performance.now()), 16) as unknown as number
  );
  vi.spyOn(window, "cancelAnimationFrame").mockImplementation((id) =>
    window.clearTimeout(id as unknown as number)
  );
  return { decodeAudioData: decodeAudioDataMock };
}

async function waitForVoiceCapture(): Promise<void> {
  await act(async () => {
    await new Promise((resolve) => setTimeout(resolve, 700));
  });
}

function bytesFromDataUrl(dataUrl: string): Uint8Array {
  const [, base64 = ""] = dataUrl.split(",");
  return Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
}

function ascii(bytes: Uint8Array, offset: number, length: number): string {
  return String.fromCharCode(...bytes.slice(offset, offset + length));
}

const MODEL_PRESETS = [
  { name: "kimi", model: "moonshot/kimi-k2.5", provider: "moonshot" },
  { name: "dflash", model: "deepseek/deepseek-v4-flash", provider: "deepseek" },
  { name: "dspro", model: "deepseek/deepseek-v4-pro", provider: "deepseek" },
];

function renderPresetComposer(
  variant: "thread" | "hero" = "thread",
  onManageModels?: () => void,
) {
  const onPresetChange = vi.fn();
  render(
    <ThreadComposer
      onSend={vi.fn()}
      modelLabel="kimi"
      modelPreset="kimi"
      modelProvider="moonshot"
      modelPresets={MODEL_PRESETS}
      onModelPresetChange={onPresetChange}
      onManageModels={onManageModels}
      placeholder={variant === "hero" ? "Ask anything..." : "Type your message..."}
      variant={variant}
    />,
  );
  return {
    badge: screen.getByRole("button", { name: "kimi" }),
    onPresetChange,
  };
}

function stubCoarsePointer(): void {
  vi.stubGlobal("matchMedia", vi.fn((query: string) => ({
    matches: query.includes("pointer: coarse"),
    media: query,
    onchange: null,
    addEventListener: vi.fn(),
    removeEventListener: vi.fn(),
    dispatchEvent: vi.fn(),
  })));
}

describe("ThreadComposer", () => {
  it("locks an async send and keeps the draft when it is rejected", async () => {
    let resolveSend!: (accepted: boolean) => void;
    const onSend = vi.fn(() => new Promise<boolean>((resolve) => {
      resolveSend = resolve;
    }));
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

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

    expect(input).toBeDisabled();
    expect(screen.getByRole("button", { name: "Send message" })).toBeDisabled();
    await act(async () => resolveSend(false));

    await waitFor(() => expect(input).toBeEnabled());
    expect(input).toHaveValue("keep this pending draft");
  });

  it("dismisses the touch keyboard after a successful send", async () => {
    vi.stubGlobal("matchMedia", vi.fn((query: string) => ({
      matches: query === "(hover: none) and (pointer: coarse)",
      media: query,
      onchange: null,
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
      dispatchEvent: vi.fn(),
    })));
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    await act(async () => {
      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
    });
    expect(input).not.toHaveFocus();
    input.focus();
    expect(input).toHaveFocus();
    fireEvent.change(input, { target: { value: "hello from mobile" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await act(async () => {
      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
    });

    expect(onSend).toHaveBeenCalledWith("hello from mobile", undefined, undefined);
    expect(input).toHaveValue("");
    expect(input).not.toHaveFocus();
  });

  it("inserts a newline instead of sending on Enter on coarse-pointer devices", () => {
    stubCoarsePointer();
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "line one" } });
    const keyEvent = createEvent.keyDown(input, { key: "Enter" });
    fireEvent(input, keyEvent);

    expect(keyEvent.defaultPrevented).toBe(false);
    expect(onSend).not.toHaveBeenCalled();
  });

  it("keeps sending on Enter on precision-pointer devices", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "desktop message" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledWith("desktop message", undefined, undefined);
  });

  it("still selects a slash command with Enter on coarse-pointer devices", () => {
    stubCoarsePointer();
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/" } });
    expect(screen.getByRole("option", { name: /\/history/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(input, { key: "Enter" });

    expect(input).toHaveValue("/history ");
    expect(onSend).not.toHaveBeenCalled();
  });

  it("labels the keyboard action as enter on coarse-pointer devices", () => {
    stubCoarsePointer();
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
      />,
    );

    expect(screen.getByLabelText("Message input")).toHaveAttribute("enterkeyhint", "enter");
  });

  it("does not set enterkeyhint on precision-pointer devices", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
      />,
    );

    expect(screen.getByLabelText("Message input")).not.toHaveAttribute("enterkeyhint");
  });

  it("focuses and sends a removable quoted answer excerpt", async () => {
    const onSend = vi.fn();
    const onQuotedContextChange = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        quotedContext="selected answer excerpt"
        focusRequest={1}
        onQuotedContextChange={onQuotedContextChange}
      />,
    );

    const input = screen.getByLabelText("Message input");
    await waitFor(() => expect(input).toHaveFocus());
    expect(screen.getByLabelText("Quoted context")).toHaveTextContent("selected answer excerpt");

    fireEvent.change(input, { target: { value: "What does this mean?" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("What does this mean?", undefined, {
      quotedContext: "selected answer excerpt",
    });
    expect(onQuotedContextChange).toHaveBeenCalledWith(null);
  });

  it("removes quoted context without clearing the draft", () => {
    const onQuotedContextChange = vi.fn();
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        quotedContext="selected answer excerpt"
        onQuotedContextChange={onQuotedContextChange}
      />,
    );

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

    expect(onQuotedContextChange).toHaveBeenCalledWith(null);
    expect(input).toHaveValue("keep this draft");
  });

  it("renders a readonly hero model composer when provided", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        modelLabel="claude-opus-4-5"
        placeholder="Ask anything..."
        variant="hero"
      />,
    );

    expect(screen.getByText("claude-opus-4-5")).toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Search" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Thinking" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Deep research" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Voice input" })).not.toBeInTheDocument();
    const input = screen.getByPlaceholderText("Ask anything...");
    expect(input).toBeInTheDocument();
    expect(input.className).toContain("min-h-[78px]");
    expect(input.className).toContain("text-composer");
    expect(input.className).toContain("pt-[27px]");
    fireEvent.change(input, { target: { value: "1" } });
    expect(input.className).toContain("pt-[27px]");
    expect(input.parentElement?.parentElement?.className).toContain("max-w-[var(--composer-content-width,58rem)]");
  });

  it("defers textarea autosizing until IME composition commits", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
      />,
    );
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    Object.defineProperty(input, "scrollHeight", {
      configurable: true,
      value: 120,
    });
    input.style.height = "50px";

    fireEvent.input(input, {
      target: { value: "zhongwen" },
      isComposing: true,
    });
    expect(input.style.height).toBe("50px");

    fireEvent.input(input, {
      target: { value: "中文" },
      isComposing: false,
    });
    expect(input.style.height).toBe("120px");
  });

  it("lets long model preset labels use their intrinsic width", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        modelLabel="gpt-5.6-sol"
        modelPreset="gpt-5-6-sol"
        modelProvider="openai_codex"
        modelPresets={[
          {
            name: "gpt-5-6-sol",
            model: "openai-codex/gpt-5.6-sol",
            provider: "openai_codex",
          },
          ...MODEL_PRESETS,
        ]}
        onModelPresetChange={vi.fn()}
        placeholder="Ask anything..."
        variant="hero"
      />,
    );

    const badge = screen.getByRole("button", { name: "gpt-5.6-sol" });
    expect(badge).toHaveClass("w-fit", "max-w-[min(18rem,44vw)]");
    expect(badge).not.toHaveClass("w-[5.75rem]");
    expect(screen.getByText("gpt-5.6-sol")).toBeInTheDocument();
  });

  it("shows a compact context meter beside the model selector", async () => {
    render(
      <ComposerUsagePopover context={{ contextTokens: 74_900, contextWindowTokens: 1_000_000 }} rounds={[]}>
        {(renderContextUsage) => <ThreadComposer
          onSend={vi.fn()}
          modelLabel="gpt-5.6-sol"
          modelPreset="gpt-5-6-sol"
          modelProvider="openai_codex"
          renderContextUsage={renderContextUsage}
          placeholder="Ask anything..."
        />}
      </ComposerUsagePopover>,
    );

    const context = screen.getByTestId("composer-context-usage");
    expect(context).toHaveClass("size-5", "rounded-full");
    expect(context).not.toHaveTextContent("Context 74.9K / 1M");
    expect(screen.getByTestId("composer-context-meter")).toBeInTheDocument();
    expect(context).toHaveAccessibleName(
      "Context 7%. Open context usage",
    );

    fireEvent.focus(context);
    const tooltip = await screen.findByRole("tooltip");
    expect(tooltip).toHaveTextContent("Context 7%");
    expect(tooltip.parentElement).not.toHaveTextContent("Available");
  });

  it("opens the current graph and replays its request snapshots from the beginning", async () => {
    // Happy DOM has no canvas renderer; supply the operations used by graph paint
    // so replay can receive the same painted-frame acknowledgement as a browser.
    vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue({
      setTransform: vi.fn(), clearRect: vi.fn(), setLineDash: vi.fn(), beginPath: vi.fn(),
      moveTo: vi.fn(), lineTo: vi.fn(), stroke: vi.fn(), arc: vi.fn(), fill: vi.fn(),
      roundRect: vi.fn(), fillText: vi.fn(), measureText: (text: string) => ({ width: text.length * 6 }),
    } as unknown as CanvasRenderingContext2D);
    render(<ComposerUsagePopover context={{ contextTokens: 200, contextWindowTokens: 1000 }} rounds={[]}
      snapshots={[
        { id: "first", contextWindowTokens: 1000, usage: { prompt_tokens: 100 }, graph: { nodes: [{ path: "/a.md", name: "a.md", state: "loaded", tokens: 40 }], edges: [] } },
        { id: "second", contextWindowTokens: 1000, usage: { prompt_tokens: 200 }, graph: { nodes: [{ path: "/b.md", name: "b.md", state: "loaded", tokens: 60 }], edges: [] } },
      ]}>
      {(renderContextUsage) => <ThreadComposer onSend={vi.fn()} renderContextUsage={renderContextUsage} />}
    </ComposerUsagePopover>);
    fireEvent.click(screen.getByTestId("composer-context-usage"));
    expect(await screen.findByRole("button", { name: "b.md" })).toBeInTheDocument();
    expect(screen.getByRole("progressbar", { name: "Context" })).toHaveAttribute("aria-valuenow", "20");
    const replay = screen.getByRole("button", { name: "Play context history" });
    fireEvent.click(replay);
    expect(replay).toBeDisabled();
    expect(screen.getByRole("progressbar", { name: "Context" })).toHaveAttribute("aria-valuenow", "10");
    expect(await screen.findByRole("button", { name: "a.md" })).toBeInTheDocument();
    await waitFor(() => expect(replay).toBeEnabled(), { timeout: 2500 });
    expect(screen.getByRole("progressbar", { name: "Context" })).toHaveAttribute("aria-valuenow", "20");
  });

  it("shows the latest round cache metrics when inspecting legacy history", () => {
    render(<ComposerUsagePopover context={{ contextTokens: 14700, contextWindowTokens: 200000 }}
      rounds={[{ inputTokens: 18000, cachedTokens: 12000 }, { inputTokens: 29400, cachedTokens: 26180 }]}>
      {(renderContextUsage) => <ThreadComposer onSend={vi.fn()} renderContextUsage={renderContextUsage} />}
    </ComposerUsagePopover>);
    fireEvent.click(screen.getByTestId("composer-context-usage"));
    const meter = screen.getByRole("progressbar", { name: "Context" });
    fireEvent.pointerEnter(meter.parentElement!.parentElement!);
    expect(screen.getByText("Cache hit rate")).toBeInTheDocument();
    expect(screen.getByText("89%")).toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Play context history" })).toBeDisabled();
  });

  it("keeps context usage visible when the provider omits cache metrics", () => {
    render(<ComposerUsagePopover context={{ contextTokens: 14700, contextWindowTokens: 200000 }} rounds={[{ inputTokens: 29400 }]}>
      {(renderContextUsage) => <ThreadComposer onSend={vi.fn()} renderContextUsage={renderContextUsage} />}
    </ComposerUsagePopover>);
    fireEvent.click(screen.getByTestId("composer-context-usage"));
    const meter = screen.getByRole("progressbar", { name: "Context" });
    expect(meter).toHaveAttribute("aria-valuenow", "7");
    fireEvent.pointerEnter(meter.parentElement!.parentElement!);
    expect(screen.queryByText("Cache hit rate")).not.toBeInTheDocument();
  });

  it("keeps the thread composer compact while matching the hero style", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        modelLabel="gpt-4o"
        modelProvider="openai"
        modelProviderLabel="OpenAI"
        placeholder="Type your message..."
      />,
    );

    expect(screen.getByText("gpt-4o")).toBeInTheDocument();
    const modelPill = screen.getByText("gpt-4o").closest(".composer-model-pill");
    expect(modelPill).toHaveClass("font-medium", "text-foreground/70");
    expect(modelPill).not.toHaveClass("font-semibold");
    const providerLogo = screen.getByTestId("composer-model-logo-openai");
    expect(providerLogo).toBeInTheDocument();
    for (const className of ["border", "bg-background"]) {
      expect(providerLogo).not.toHaveClass(className);
    }
    const input = screen.getByPlaceholderText("Type your message...");
    expect(input.className).toContain("min-h-[50px]");
    expect(input.className).toContain("text-composer");
    expect(input.parentElement?.parentElement?.className).toContain("max-w-[var(--composer-content-width,49.5rem)]");
    expect(input.parentElement?.parentElement?.className).toContain("rounded-panel");
    expect(input.parentElement?.parentElement?.className).not.toContain("shadow-");
    expect(screen.getByRole("button", { name: "Send message" }).className).toContain("bg-foreground");
    expect(screen.queryByText(/Enter to send/)).not.toBeInTheDocument();
  });

  it("opens a model picker and switches presets with one click", async () => {
    const { badge, onPresetChange } = renderPresetComposer();
    expect(badge).toHaveClass("h-9");
    expect(badge).toHaveClass("w-fit");
    fireEvent.click(badge);
    const picker = screen.getByRole("dialog", { name: "Switch model" });
    expect(picker).toHaveClass("w-[min(18rem,calc(100vw-2rem))]");
    expect(badge).toHaveClass("w-fit");
    expect(badge.querySelector(".composer-model-pill")).not.toHaveClass("w-full");
    expect(within(picker).getAllByRole("option")).toHaveLength(3);
    expect(within(picker).getByRole("option", { name: "dflash" })).toHaveTextContent(
      /dflash\s*deepseek-v4-flash/,
    );
    expect(within(picker).getByRole("option", { name: "kimi" })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    expect(document.activeElement).toBe(within(picker).getByRole("option", { name: "kimi" }));
    fireEvent.click(within(picker).getByRole("option", { name: "dspro" }));
    expect(onPresetChange).toHaveBeenCalledWith("dspro");
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
    expect(badge).toHaveClass("w-fit");
  });

  it("opens model settings from the picker footer", async () => {
    const onManageModels = vi.fn();
    const { badge } = renderPresetComposer("thread", onManageModels);

    fireEvent.click(badge);
    const picker = screen.getByRole("dialog", { name: "Switch model" });
    fireEvent.click(within(picker).getByRole("button", { name: "Manage presets" }));

    expect(onManageModels).toHaveBeenCalledTimes(1);
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
  });

  it("keeps long-press drag switching alongside the click picker", () => {
    vi.useFakeTimers();
    const { badge, onPresetChange } = renderPresetComposer();

    fireEvent.pointerDown(badge, { pointerId: 1, pointerType: "touch", clientY: 100 });
    act(() => vi.advanceTimersByTime(400));
    expect(screen.getByTestId("composer-model-pill-viewport")).toBeInTheDocument();
    expect(screen.getByTestId("composer-model-pill-layout")).toHaveClass("invisible");
    expect(screen.getByTestId("composer-model-pill-track")).not.toHaveClass("transition-transform");

    fireEvent.pointerMove(badge, { pointerId: 1, pointerType: "touch", clientY: 56 });
    fireEvent.pointerUp(badge, { pointerId: 1, pointerType: "touch", clientY: 56 });
    expect(onPresetChange).toHaveBeenCalledWith("dflash");
    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
    vi.useRealTimers();
  });

  it("uses the same click picker in hero mode", () => {
    const { badge, onPresetChange } = renderPresetComposer("hero");
    expect(badge).toHaveClass("h-8");
    fireEvent.click(badge);
    fireEvent.click(screen.getByRole("option", { name: "dflash" }));
    expect(onPresetChange).toHaveBeenCalledWith("dflash");
  });

  it("switches the same primary button between voice and send as the draft changes", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} onTranscribeAudio={vi.fn(async () => "voice")} />);
    const input = screen.getByRole("textbox");
    const action = screen.getByRole("button", { name: "Voice input" });
    expect(screen.queryByRole("button", { name: "Send message" })).not.toBeInTheDocument();
    fireEvent.change(input, { target: { value: "   " } });
    expect(screen.getByRole("button", { name: "Voice input" })).toBe(action);
    fireEvent.change(input, { target: { value: "send this" } });
    expect(screen.getByRole("button", { name: "Send message" })).toBe(action);
    expect(screen.queryByRole("button", { name: "Voice input" })).not.toBeInTheDocument();
    fireEvent.click(action);
    expect(onSend).toHaveBeenCalledWith("send this", undefined, undefined);
    expect(screen.getByRole("button", { name: "Voice input" })).toBe(action);
  });

  it("uses send for an attachment-only draft and restores voice after removal", async () => {
    mockBlobUrls();
    const { container } = render(<ThreadComposer onSend={vi.fn()} onTranscribeAudio={vi.fn(async () => "voice")} />);
    fireEvent.change(container.querySelector('input[type="file"]')!, {
      target: { files: [new File(["image"], "photo.png", { type: "image/png" })] },
    });
    await waitFor(() => expect(screen.getByRole("button", { name: "Send message" })).toBeEnabled());
    expect(screen.queryByRole("button", { name: "Voice input" })).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Remove attachment" }));
    expect(screen.getByRole("button", { name: "Voice input" })).toBeInTheDocument();
  });

  it("transcribes voice input into the composer without sending", async () => {
    mockVoiceRecorder();
    const onSend = vi.fn();
    const onTranscribeAudio = vi.fn(async () => "hello voice");
    render(
      <ThreadComposer
        onSend={onSend}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalledWith(
      expect.stringMatching(/^data:audio\/webm;base64,/),
      expect.objectContaining({ durationMs: expect.any(Number) }),
    ));
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("hello voice"));
    expect(onSend).not.toHaveBeenCalled();
  });

  it("explains the HTTPS requirement for voice input on an insecure origin", async () => {
    const { getUserMedia } = mockVoiceRecorder();
    vi.stubGlobal("isSecureContext", false);
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={vi.fn(async () => "unused")}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));

    expect(
      await screen.findByText(
        "Chrome and other browsers block microphone access on remote HTTP pages for security. "
          + "Open this WebUI over HTTPS to use voice input.",
      ),
    ).toBeInTheDocument();
    expect(screen.getByRole("alert")).toHaveClass("max-h-24");
    expect(getUserMedia).not.toHaveBeenCalled();
  });

  it("keeps the unsupported-browser error for secure origins without recording support", async () => {
    const { getUserMedia } = mockVoiceRecorder();
    vi.stubGlobal("isSecureContext", true);
    vi.stubGlobal("MediaRecorder", undefined);
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={vi.fn(async () => "unused")}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));

    expect(
      await screen.findByText("Voice input is not supported in this browser."),
    ).toBeInTheDocument();
    expect(getUserMedia).not.toHaveBeenCalled();
  });

  it("converts voice recordings to wav for Xiaomi MiMo transcription", async () => {
    mockVoiceRecorder(new Blob([new Uint8Array([1, 2, 3, 4])], { type: "audio/webm" }));
    const { decodeAudioData } = mockVoiceAudioInput(
      180,
      "running",
      [new Float32Array([0, 0.5, -0.5])],
    );
    const onTranscribeAudio = vi.fn<NonNullable<React.ComponentProps<typeof ThreadComposer>["onTranscribeAudio"]>>(
      async () => "mimo voice",
    );
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
        transcriptionProvider="xiaomi_mimo"
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalledTimes(1));
    const [dataUrl, options] = onTranscribeAudio.mock.calls[0];
    expect(dataUrl).toMatch(/^data:audio\/wav;base64,/);
    expect(options).toEqual(expect.objectContaining({ durationMs: expect.any(Number) }));
    expect(decodeAudioData).toHaveBeenCalledTimes(1);

    const bytes = bytesFromDataUrl(dataUrl);
    const view = new DataView(bytes.buffer);
    expect(ascii(bytes, 0, 4)).toBe("RIFF");
    expect(ascii(bytes, 8, 4)).toBe("WAVE");
    expect(ascii(bytes, 12, 4)).toBe("fmt ");
    expect(view.getUint16(20, true)).toBe(1);
    expect(view.getUint16(22, true)).toBe(1);
    expect(view.getUint32(24, true)).toBe(16_000);
    expect(view.getUint16(34, true)).toBe(16);
    expect(ascii(bytes, 36, 4)).toBe("data");
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("mimo voice"));
  });

  it("does not start duplicate voice recordings while microphone access is pending", async () => {
    const { getUserMedia, stopTrack } = mockVoiceRecorder();
    let resolveStream: ((stream: Awaited<ReturnType<typeof getUserMedia>>) => void) | undefined;
    getUserMedia.mockImplementation(() => new Promise((resolve) => {
      resolveStream = resolve;
    }));
    const onTranscribeAudio = vi.fn(async () => "one recording");
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const voiceButton = screen.getByRole("button", { name: "Voice input" });
    fireEvent.click(voiceButton);
    fireEvent.click(voiceButton);

    expect(getUserMedia).toHaveBeenCalledTimes(1);

    await act(async () => {
      resolveStream?.({ getTracks: () => [{ stop: stopTrack }] });
    });
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalledTimes(1));
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("one recording"));
  });

  it("distinguishes a missing microphone from a blocked permission", async () => {
    const { getUserMedia } = mockVoiceRecorder();
    getUserMedia.mockRejectedValue(Object.assign(new Error("no microphone"), {
      name: "NotFoundError",
    }));
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={vi.fn(async () => "unused")}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));

    await waitFor(() => {
      expect(screen.getByText("No microphone was found. Connect a microphone and try again.")).toBeInTheDocument();
    });
  });

  it("clears a previous voice error when retrying microphone access", async () => {
    const { getUserMedia } = mockVoiceRecorder();
    getUserMedia.mockRejectedValueOnce(new Error("permission denied"));
    const onTranscribeAudio = vi.fn(async () => "voice retry");
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const voiceButton = screen.getByRole("button", { name: "Voice input" });
    fireEvent.click(voiceButton);
    await waitFor(() => expect(screen.getByText("Allow microphone access in the address bar, then retry.")).toBeInTheDocument());

    fireEvent.click(voiceButton);

    await waitFor(() => expect(screen.queryByText("Allow microphone access in the address bar, then retry.")).not.toBeInTheDocument());
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));
  });

  it("supports press-and-hold voice recording", async () => {
    mockVoiceRecorder();
    const onSend = vi.fn();
    const onTranscribeAudio = vi.fn(async () => "held voice");
    render(
      <ThreadComposer
        onSend={onSend}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const voiceButton = screen.getByRole("button", { name: "Voice input" });
    fireEvent.pointerDown(voiceButton, { button: 0, pointerId: 1, pointerType: "touch" });
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 180));
    });
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.pointerUp(screen.getByRole("button", { name: "Stop recording" }), {
      pointerId: 1,
      pointerType: "touch",
    });

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalled());
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("held voice"));
    expect(onSend).not.toHaveBeenCalled();
  });

  it("supports keyboard hold voice recording", async () => {
    mockVoiceRecorder();
    const onSend = vi.fn();
    const onTranscribeAudio = vi.fn(async () => "shortcut voice");
    render(
      <ThreadComposer
        onSend={onSend}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const voiceButton = screen.getByRole("button", { name: "Voice input" });
    expect(voiceButton).not.toHaveAttribute("title");
    expect(voiceButton).toHaveAttribute("aria-keyshortcuts", "Control+Shift+D");
    fireEvent.keyDown(window, { code: "KeyD", ctrlKey: true, key: "D", shiftKey: true });
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.keyUp(window, { code: "KeyD", ctrlKey: true, key: "D", shiftKey: true });

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalled());
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("shortcut voice"));
    expect(onSend).not.toHaveBeenCalled();
  });

  it("ignores the delayed click emitted after a long-press voice recording", async () => {
    const { getUserMedia } = mockVoiceRecorder();
    const onSend = vi.fn();
    const onTranscribeAudio = vi.fn(async () => "held once");
    render(
      <ThreadComposer
        onSend={onSend}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const voiceButton = screen.getByRole("button", { name: "Voice input" });
    fireEvent.pointerDown(voiceButton, { button: 0, pointerId: 1, pointerType: "touch" });
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 180));
    });
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.pointerUp(screen.getByRole("button", { name: "Stop recording" }), {
      pointerId: 1,
      pointerType: "touch",
    });
    await waitFor(() => expect(screen.getByLabelText("Message input")).toHaveValue("held once"));

    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 20));
    });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).not.toHaveBeenCalled();
    expect(getUserMedia).toHaveBeenCalledTimes(1);
    expect(onTranscribeAudio).toHaveBeenCalledTimes(1);
  });

  it("keeps existing text when voice transcription fails", async () => {
    mockVoiceRecorder();
    const onSend = vi.fn();
    const onTranscribeAudio = vi.fn(async () => {
      throw new Error("not_configured");
    });
    render(
      <ThreadComposer
        onSend={onSend}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "draft" } });
    fireEvent.keyDown(window, { key: "D", code: "KeyD", ctrlKey: true, shiftKey: true });
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await waitForVoiceCapture();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => {
      expect(screen.getByText("Configure a transcription provider first.")).toBeInTheDocument();
    });
    expect(input).toHaveValue("draft");
    expect(onSend).not.toHaveBeenCalled();
  });

  it("does not transcribe recordings that are too short", async () => {
    mockVoiceRecorder();
    const onTranscribeAudio = vi.fn(async () => "should not appear");
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => {
      expect(screen.getByText("Hold a little longer to record voice.")).toBeInTheDocument();
    });
    expect(onTranscribeAudio).not.toHaveBeenCalled();
  });

  it("transcribes recorded audio even when waveform samples are silent", async () => {
    mockVoiceRecorder();
    mockVoiceAudioInput();
    const onTranscribeAudio = vi.fn(async () => "quiet voice");
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 1_150));
    });

    expect(screen.queryByText("No microphone input detected.")).not.toBeInTheDocument();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalledTimes(1));
    expect(screen.getByDisplayValue("quiet voice")).toBeInTheDocument();
  });

  it("does not treat unavailable microphone levels as silence", async () => {
    mockVoiceRecorder();
    mockVoiceAudioInput(128, "suspended");
    const onTranscribeAudio = vi.fn(async () => "voice text");
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Voice input" }));
    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 1_150));
    });

    expect(screen.queryByText("No microphone input detected.")).not.toBeInTheDocument();
    fireEvent.click(await screen.findByRole("button", { name: "Stop recording" }));

    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalledTimes(1));
    expect(screen.getByDisplayValue("voice text")).toBeInTheDocument();
  });

  it.each(["thread", "hero"] as const)("keeps narrow %s permissions inline and usage below without losing the draft", async (variant) => {
    let width = 390;
    vi.stubGlobal("innerWidth", width);
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockImplementation(
      () => rect({ width, height: 160 }),
    );
    const onSend = vi.fn();
    const onWorkspaceScopeChange = vi.fn();
    const { container } = render(
      <ComposerUsagePopover context={{ contextTokens: 500, contextWindowTokens: 1000 }} rounds={[]}>
        {(renderContextUsage) => <ThreadComposer
          variant={variant}
          compactWhenIdle
          onSend={onSend}
          modelLabel="codex"
          workspaceScope={{ project_path: "/tmp/project", project_name: "project", access_mode: "full", restrict_to_workspace: false }}
          onWorkspaceScopeChange={onWorkspaceScopeChange}
          renderContextUsage={renderContextUsage}
        />}
      </ComposerUsagePopover>,
    );
    const form = container.querySelector("form")!;
    const input = screen.getByRole("textbox");
    const access = screen.getByRole("button", { name: "Workspace access mode: Full Access" });
    const meta = container.querySelector(".thread-composer-meta")!;
    const primary = container.querySelector(".thread-composer-footer-primary")!;
    expect(form).toHaveAttribute("data-compact-controls", "true");
    expect(container.querySelector(".thread-composer-surface")).not.toHaveAttribute("data-compact");
    expect(primary).toContainElement(access);
    expect(meta).toContainElement(screen.getByTestId("composer-context-usage"));
    expect(within(meta as HTMLElement).getByText("Context 50%")).toBeVisible();
    expect(container.querySelector(".thread-composer-footer-actions")).toContainElement(screen.getByLabelText("codex"));
    fireEvent.change(input, { target: { value: "keep this draft" } });

    // A narrow desktop panel uses the same layout; resizing must not replace the textarea.
    width = 800;
    vi.stubGlobal("innerWidth", width);
    fireEvent(window, new Event("resize"));
    expect(form).not.toHaveAttribute("data-compact-controls");
    expect(primary).toContainElement(access);
    expect(screen.getByRole("textbox")).toBe(input);
    expect(input).toHaveValue("keep this draft");
    expect(container.querySelector(".thread-composer-footer-actions")).toContainElement(screen.getByLabelText("codex"));
    expect(screen.getAllByRole("button", { name: "Workspace access mode: Full Access" })).toHaveLength(1);

    width = 320;
    fireEvent(window, new Event("resize"));
    expect(form).toHaveAttribute("data-compact-controls", "true");
    expect(input).toHaveValue("keep this draft");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    await waitFor(() => expect(onSend).toHaveBeenCalledWith("keep this draft", undefined, undefined));
    expect(onWorkspaceScopeChange).not.toHaveBeenCalled();
  });

  it.each(["thread", "hero"] as const)("places %s mobile permission opposite workspace below the composer", async (variant) => {
    vi.stubGlobal("matchMedia", vi.fn((query: string) => ({
      matches: query === "(max-width: 639px)" || query.includes("pointer: coarse"),
      media: query,
      addEventListener: vi.fn(),
      removeEventListener: vi.fn(),
    })));
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockReturnValue(rect({ width: 320, height: 160 }));
    const scope = { project_path: "/srv/workspace", project_name: "workspace", access_mode: "full" as const };
    const onWorkspaceScopeChange = vi.fn();
    const { container } = render(<ComposerUsagePopover context={{ contextTokens: 500, contextWindowTokens: 1000 }} rounds={[]}>
      {(renderContextUsage) => <ThreadComposer variant={variant} onSend={vi.fn()} workspaceScope={scope}
        workspaceDefaultScope={scope} {...workspacePickerProps(scope)} workspaceControls={{ can_change_project: true }}
        onWorkspaceScopeChange={onWorkspaceScopeChange} renderContextUsage={renderContextUsage} />}
    </ComposerUsagePopover>);
    const meta = container.querySelector(".thread-composer-meta")!;
    const workspace = screen.getByRole("button", { name: "Switch directory" });
    const access = screen.getByRole("button", { name: "Workspace access mode: Full Access" });
    expect(container.querySelector(".thread-composer-surface")!.nextElementSibling).toBe(meta);
    expect(meta.querySelector(".thread-composer-workspace-group")).toContainElement(workspace);
    expect(meta).toContainElement(access);
    const usage = screen.getByTestId("composer-context-usage");
    expect(meta).toContainElement(usage);
    expect(usage).toHaveTextContent(/^50%$/);
    expect(usage).toHaveAccessibleName("Context 50%. Open context usage");
    expect(access.closest(".thread-composer-footer-primary")).toBeNull();
    const user = userEvent.setup();
    await user.click(access);
    await user.click(screen.getByRole("menuitemradio", { name: "Default Permission" }));
    expect(onWorkspaceScopeChange).toHaveBeenCalledWith(expect.objectContaining({ access_mode: "restricted" }));
  });

  it.each(["handle tap", "Escape"])("opens narrow context usage as a bottom sheet and restores interaction after %s", async (dismissal) => {
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockReturnValue(
      rect({ width: 390, height: 160 }),
    );
    vi.stubGlobal("innerWidth", 390);
    const user = userEvent.setup();
    const onSend = vi.fn();
    render(
      <ComposerUsagePopover context={{ contextTokens: 10000, contextWindowTokens: 200000 }}
        rounds={[{ inputTokens: 10000, cachedTokens: 8000 }]}>
        {(renderContextUsage) => <ThreadComposer onSend={onSend} renderContextUsage={renderContextUsage} />}
      </ComposerUsagePopover>,
    );
    const trigger = screen.getByTestId("composer-context-usage");
    await user.click(trigger);
    const sheet = screen.getByRole("dialog", { name: "Context usage" });
    expect(sheet).toHaveClass("mt-auto", "h-[85%]");
    expect(sheet.contains(document.activeElement)).toBe(true);
    expect(within(sheet).getByRole("heading", { name: "Context usage" })).toBeInTheDocument();
    expect(within(sheet).getByRole("progressbar", { name: "Context" })).toHaveAttribute("aria-valuenow", "5");
    expect(within(sheet).getByRole("button", { name: "Play context history" })).toBeDisabled();
    expect(document.body).toHaveStyle({ pointerEvents: "none" });

    if (dismissal === "Escape") await user.keyboard("{Escape}");
    else await user.click(within(sheet).getByRole("button", { name: "Close" }));
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
    expect(document.body).not.toHaveStyle({ pointerEvents: "none" });
    expect(trigger).toHaveFocus();
    await user.type(screen.getByRole("textbox"), "still works");
    await user.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("still works", undefined, undefined);
  });

  it("releases the mobile modal lock when resizing and keeps the desktop sidebar open", async () => {
    let width = 390;
    vi.stubGlobal("innerWidth", width);
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockImplementation(
      () => rect({ width, height: 160 }),
    );
    const user = userEvent.setup();
    render(<ComposerUsagePopover context={{ contextTokens: 500, contextWindowTokens: 1000 }} rounds={[]}>
      {(renderContextUsage) => <ThreadComposer onSend={vi.fn()} renderContextUsage={renderContextUsage} />}
    </ComposerUsagePopover>);
    await user.click(screen.getByTestId("composer-context-usage"));
    expect(screen.getByRole("dialog")).toHaveClass("mt-auto");

    width = 800;
    vi.stubGlobal("innerWidth", width);
    fireEvent(window, new Event("resize"));
    await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument());
    expect(document.body).not.toHaveStyle({ pointerEvents: "none" });
    expect(screen.getByRole("complementary", { name: "Context usage" })).toBeInTheDocument();
    expect(screen.getByRole("progressbar", { name: "Context" })).toHaveAttribute("aria-valuenow", "50");
  });

  it.each([
    ["restricted", "Default Permission", "Read files, edit files, and run commands only inside the working directory."],
    ["full", "Full Access", "Allow file access and commands outside the working directory."],
  ] as const)("explains the current %s permission on hover", async (mode, label, description) => {
    const user = userEvent.setup();
    render(<ThreadComposer onSend={vi.fn()} workspaceScope={{ project_path: "/tmp/project", project_name: "project", access_mode: mode, restrict_to_workspace: mode === "restricted" }} onWorkspaceScopeChange={vi.fn()} />);
    const access = screen.getByRole("button", { name: `Workspace access mode: ${label}` });
    expect(access).toHaveTextContent(label);
    expect(document.getElementById(access.getAttribute("aria-describedby")!)).toHaveTextContent(description);
    await user.hover(access);
    expect(await screen.findByRole("tooltip")).toHaveTextContent(description);
  });

  it("changes access only after selecting a different menu option and preserves the project", async () => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const restricted: WorkspaceScopePayload = {
      project_path: "/tmp/project", project_name: "project",
      access_mode: "restricted", restrict_to_workspace: true,
    };
    const composer = (workspaceScope: WorkspaceScopePayload, disabled = false) => (
      <ThreadComposer onSend={vi.fn()} placeholder="Type your message..."
        workspaceScope={workspaceScope} workspaceScopeDisabled={disabled}
        onWorkspaceScopeChange={onWorkspaceScopeChange} />
    );
    const { rerender } = render(composer(restricted));
    const access = screen.getByRole("button", { name: "Workspace access mode: Default Permission" });
    const full = { ...restricted, access_mode: "full" as const, restrict_to_workspace: false };
    await user.click(access);
    expect(screen.getByRole("menuitemradio", { name: "Default Permission" })).toHaveAttribute("aria-checked", "true");
    expect(screen.getByRole("menuitemradio", { name: "Full Access" })).toHaveAttribute("aria-checked", "false");
    expect(onWorkspaceScopeChange).not.toHaveBeenCalled();
    await user.click(screen.getByRole("menuitemradio", { name: "Default Permission" }));
    expect(onWorkspaceScopeChange).not.toHaveBeenCalled();
    await user.click(access);
    await user.click(screen.getByRole("menuitemradio", { name: "Full Access" }));
    expect(onWorkspaceScopeChange).toHaveBeenCalledTimes(1);
    expect(onWorkspaceScopeChange).toHaveBeenCalledWith(full);
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    rerender(composer(full));
    expect(access).toHaveAccessibleName("Workspace access mode: Full Access");
    await user.click(access);
    expect(screen.getByRole("menuitemradio", { name: "Full Access" })).toHaveAttribute("aria-checked", "true");
    await user.keyboard("{Escape}");
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    expect(onWorkspaceScopeChange).toHaveBeenCalledTimes(1);
    await waitFor(() => expect(access).toHaveFocus());
    await user.keyboard("{Enter}{Home}{Enter}");
    expect(onWorkspaceScopeChange).toHaveBeenLastCalledWith(restricted);
    rerender(composer(full, true));
    expect(access).toBeDisabled();
    await user.click(access);
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    expect(onWorkspaceScopeChange).toHaveBeenCalledTimes(2);
  });

  it("opens project selection in a searchable dialog", async () => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const defaultScope = {
      project_path: "/Users/test/.nanobot/workspace",
      project_name: "workspace",
      access_mode: "restricted" as const,
      restrict_to_workspace: true,
    };
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        variant="hero"
        workspaceScope={{
          ...defaultScope,
          access_mode: "full",
          restrict_to_workspace: false,
        }}
        workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)}
        workspaceControls={{ can_change_project: true, can_browse_directories: true, can_resolve_project: true }}
        onWorkspaceScopeChange={onWorkspaceScopeChange}
      />,
    );

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

    expect(await screen.findByRole("button", { name: "/Users/test/.nanobot/workspace" })).toBeInTheDocument();
    expect(screen.getByRole("dialog")).toBeInTheDocument();

    await user.click(screen.getByRole("button", { name: /^Edit path:/ }));
    const input = screen.getByRole("combobox");
    fireEvent.change(input, { target: { value: "relative/project" } });
    expect(screen.queryByRole("option", { name: "relative/project" })).not.toBeInTheDocument();
    expect(onWorkspaceScopeChange).not.toHaveBeenCalled();

    fireEvent.change(input, { target: { value: "/Users/test/project-alpha" } });
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    await user.click(screen.getByRole("button", { name: "Confirm" }));

    expect(onWorkspaceScopeChange).toHaveBeenCalledWith(expect.objectContaining({
      project_path: "/Users/test/project-alpha",
      project_name: "project-alpha",
      access_mode: "full",
      restrict_to_workspace: false,
    }));

    await user.click(screen.getByRole("button", { name: "Switch directory" }));
    await user.click(screen.getByRole("button", { name: /^Edit path:/ }));
    const reopenedInput = await screen.findByRole("combobox");
    fireEvent.change(reopenedInput, { target: { value: "~/Pictures/Photos" } });
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    await user.click(screen.getByRole("button", { name: "Confirm" }));

    expect(onWorkspaceScopeChange).toHaveBeenLastCalledWith(expect.objectContaining({
      project_path: "/Users/test/Pictures/Photos",
      project_name: "Photos",
      access_mode: "full",
      restrict_to_workspace: false,
    }));
  });

  it.each([
    ["Windows", "D:\\Users\\test\\.nanobot\\workspace", "D:\\path\\to\\project"],
    ["Windows UNC", "\\\\server\\share\\workspace", "\\\\server\\share\\project"],
    ["macOS", "/Users/test/.nanobot/workspace", "/Users/name/project"],
    ["Linux", "/home/test/.nanobot/workspace", "/home/name/project"],
  ])("accepts a %s project path", async (_, projectPath, selectedPath) => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const defaultScope = {
      project_path: projectPath,
      project_name: "workspace",
      access_mode: "restricted" as const,
      restrict_to_workspace: true,
    };

    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        variant="hero"
        workspaceScope={defaultScope}
        workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)}
        workspaceControls={{ can_change_project: true }}
        onWorkspaceScopeChange={onWorkspaceScopeChange}
      />,
    );

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

    fireEvent.change(await screen.findByRole("combobox"), { target: { value: selectedPath } });
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    fireEvent.keyDown(screen.getByRole("combobox"), { key: "Enter" });
    await waitFor(() => expect(onWorkspaceScopeChange).toHaveBeenCalledWith(expect.objectContaining({ project_path: selectedPath })));
  });

  it("locks project selection independently of the editable permission menu", async () => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const defaultScope = {
      project_path: "/Users/test/.nanobot/workspace",
      project_name: "workspace",
      access_mode: "full" as const,
      restrict_to_workspace: false,
    };
    const composer = (workspaceControlsHidden: boolean, variant: "hero" | "thread" = "hero", workspaceProjectLocked = false) => (
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        variant={variant}
        workspaceControlsHidden={workspaceControlsHidden}
        workspaceProjectLocked={workspaceProjectLocked}
        workspaceScope={defaultScope}
        workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)}
        workspaceControls={{ can_change_project: true }}
        onWorkspaceScopeChange={onWorkspaceScopeChange}
      />
    );
    const { container, rerender } = render(composer(false));
    const trigger = screen.getByRole("button", { name: "Switch directory" });
    expect(trigger).toHaveTextContent("workspace");
    const access = screen.getByRole("button", { name: "Workspace access mode: Full Access" });
    const footer = container.querySelector(".thread-composer-footer-primary")!;
    expect(Array.from(footer.querySelectorAll("button"))).toEqual([
      screen.getByRole("button", { name: "Attach files" }), access,
    ]);
    const meta = container.querySelector(".thread-composer-meta")!;
    expect(meta).toContainElement(trigger);
    expect(container.querySelector(".thread-composer-surface")!.nextElementSibling).toBe(meta);
    rerender(composer(true));
    expect(screen.queryByRole("button", { name: "Switch directory" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Workspace access mode: Full Access" })).not.toBeInTheDocument();
    rerender(composer(false));
    expect(screen.getByRole("button", { name: "Switch directory" })).toBeEnabled();
    rerender(composer(false, "thread"));
    expect(screen.getByRole("button", { name: "Switch directory" })).toBeEnabled();
    rerender(composer(false, "thread", true));
    expect(screen.queryByRole("button", { name: "Switch directory" })).not.toBeInTheDocument();
    expect(container.querySelector(".thread-composer-workspace-label")).not.toBeInTheDocument();
    const accessAfterLock = screen.getByRole("button", { name: "Workspace access mode: Full Access" });
    await user.click(accessAfterLock);
    await user.click(screen.getByRole("menuitemradio", { name: "Default Permission" }));
    expect(onWorkspaceScopeChange).toHaveBeenCalledWith({
      ...defaultScope, access_mode: "restricted", restrict_to_workspace: true,
    });
    rerender(composer(true, "thread", true));
    expect(screen.queryByText("workspace")).not.toBeInTheDocument();
  });

  it("keeps the inline permission menu and directory picker mounted across composer widths", () => {
    let width = 390;
    vi.stubGlobal("innerWidth", width);
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockImplementation(() => rect({ width, height: 160 }));
    const defaultScope = { project_path: "/srv/workspace", project_name: "workspace", access_mode: "full" as const };
    const { container } = render(<ThreadComposer variant="hero" onSend={vi.fn()} workspaceScope={defaultScope}
      workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)} workspaceControls={{ can_change_project: true }} onWorkspaceScopeChange={vi.fn()} />);
    const input = screen.getByRole("textbox");
    const row = container.querySelector(".thread-composer-meta")!;
    const trigger = screen.getByRole("button", { name: "Switch directory" });
    const access = screen.getByRole("button", { name: "Workspace access mode: Full Access" });
    expect(row.querySelector(".thread-composer-workspace-group")).toContainElement(trigger);
    expect(container.querySelector(".thread-composer-footer-primary")).toContainElement(access);
    width = 800;
    vi.stubGlobal("innerWidth", width);
    fireEvent(window, new Event("resize"));
    expect(container.querySelector(".thread-composer-meta")).toBe(row);
    expect(screen.getByRole("button", { name: "Switch directory" })).toBe(trigger);
    expect(screen.getByRole("button", { name: "Workspace access mode: Full Access" })).toBe(access);
    expect(screen.getByRole("textbox")).toBe(input);
  });

  it("browses and selects the connected host's project in one dialog on a native client", async () => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const defaultScope = {
      project_path: "/Users/test/.nanobot/workspace",
      project_name: "workspace",
      access_mode: "full" as const,
      restrict_to_workspace: false,
    };
    const project = { path: `${defaultScope.project_path}/project`, name: "project" };
    const onBrowseWorkspaceDirectories = vi.fn((rawPath: string) => {
      const path = rawPath.replace(/\/$/, "");
      return Promise.resolve({
        path, parent: path === defaultScope.project_path ? "/Users/test/.nanobot" : defaultScope.project_path,
        entries: path === defaultScope.project_path ? [project] : [],
        truncated: false, host: "dev-mac", platform: "Darwin",
      });
    });
    const onResolveWorkspaceProject = vi.fn().mockResolvedValue(project);
    Object.defineProperty(window, "nanobotHost", {
      configurable: true,
      value: {
        getRuntimeInfo: vi.fn(),
        restartEngine: vi.fn(),
        openLogs: vi.fn(),
        exportDiagnostics: vi.fn(),
      },
    });

    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        variant="hero"
        workspaceScope={defaultScope}
        workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)}
        workspaceControls={{
          can_change_project: true,
          can_browse_directories: true,
          can_resolve_project: true,
        }}
        onBrowseWorkspaceDirectories={onBrowseWorkspaceDirectories}
        onResolveWorkspaceProject={onResolveWorkspaceProject}
        onWorkspaceScopeChange={onWorkspaceScopeChange}
      />,
    );

    await user.click(screen.getByRole("button", { name: "Switch directory" }));
    expect(screen.getByRole("dialog", { name: "Choose directory" })).toBeInTheDocument();
    await user.click(await screen.findByRole("option", { name: project.path }));
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    expect(onWorkspaceScopeChange).not.toHaveBeenCalled();
    await user.click(screen.getByRole("button", { name: "Confirm" }));
    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Choose directory" })).not.toBeInTheDocument());
    expect(onResolveWorkspaceProject).toHaveBeenCalledWith(project.path);
    expect(onWorkspaceScopeChange).toHaveBeenCalledWith(expect.objectContaining({
      project_path: project.path,
      project_name: project.name,
      access_mode: "full",
      restrict_to_workspace: false,
    }));
  });

  it("preserves Full Access when selecting an entered host path", async () => {
    const user = userEvent.setup();
    const onWorkspaceScopeChange = vi.fn();
    const defaultScope = {
      project_path: "/srv/nanobot/workspace",
      project_name: "workspace",
      access_mode: "full" as const,
      restrict_to_workspace: false,
    };
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        variant="hero"
        workspaceScope={defaultScope}
        workspaceDefaultScope={defaultScope}
        {...workspacePickerProps(defaultScope)}
        workspaceControls={{
          can_change_project: true,
        }}
        onWorkspaceScopeChange={onWorkspaceScopeChange}
      />,
    );

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

    expect(await screen.findByRole("combobox")).toBeInTheDocument();

    fireEvent.change(screen.getByRole("combobox"), {
      target: { value: "/srv/nas-project" },
    });
    await waitFor(() => expect(screen.getByRole("button", { name: "Confirm" })).toBeEnabled());
    await user.click(screen.getByRole("button", { name: "Confirm" }));

    expect(onWorkspaceScopeChange).toHaveBeenCalledWith(expect.objectContaining({
      project_path: "/srv/nas-project",
      access_mode: "full",
      restrict_to_workspace: false,
    }));
  });


  it("closes the sustained goal through its existing drawer", () => {
    const { container, rerender } = render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        goalState={{
          active: true,
          objective: "Ship the release",
          ui_summary: "Preparing release",
        }}
      />,
    );

    const drawer = container.querySelector("[data-composer-status-drawer]");
    expect(drawer).not.toBeNull();
    expect(drawer).toHaveAttribute("data-state", "open");
    expect(drawer).not.toHaveAttribute("aria-hidden");
    const status = screen.getByRole("status");
    expect(status).toHaveClass("composer-status-drawer-content");

    rerender(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        goalState={{ active: false }}
      />,
    );

    expect(container.querySelector("[data-composer-status-drawer]")).toBe(drawer);
    expect(drawer).toHaveAttribute("data-state", "closed");
    expect(drawer).toHaveAttribute("aria-hidden", "true");
    expect(screen.queryByRole("status")).not.toBeInTheDocument();
    expect(drawer?.querySelector('[role="status"]')).toBe(status);

    fireEvent.transitionEnd(drawer as Element, { propertyName: "grid-template-rows" });
    expect(container.querySelector("[data-composer-status-drawer]")).toBeNull();
  });

  it("shows full goal content and dismisses it without losing the composer draft", async () => {
    const user = userEvent.setup();
    const longObjective =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz0123456789GoalTail";
    render(
      <ThreadComposer
        onSend={vi.fn()}
        persistDraft={false}
        placeholder="Type your message..."
        goalState={{
          active: true,
          objective: longObjective,
          ui_summary: "Short summary for strip",
        }}
      />,
    );

    const input = screen.getByRole("textbox", { name: "Message input" });
    const trigger = screen.getByRole("button", { name: "Show full goal" });
    await user.type(input, "Keep my draft");
    await user.click(trigger);

    const dialog = await screen.findByRole("dialog", { name: "Goal" });
    expect(dialog).toHaveTextContent("Short summary for strip");
    expect(dialog).toHaveTextContent(longObjective);
    expect(trigger).toHaveAttribute("aria-expanded", "true");

    await user.click(trigger);
    expect(screen.queryByRole("dialog", { name: "Goal" })).not.toBeInTheDocument();
    expect(trigger).toHaveAttribute("aria-expanded", "false");

    await user.click(trigger);
    expect(await screen.findByRole("dialog", { name: "Goal" })).toBeVisible();
    await user.keyboard("{Escape}");
    expect(screen.queryByRole("dialog", { name: "Goal" })).not.toBeInTheDocument();

    await user.click(trigger);
    expect(await screen.findByRole("dialog", { name: "Goal" })).toBeVisible();
    await user.click(input);
    expect(screen.queryByRole("dialog", { name: "Goal" })).not.toBeInTheDocument();
    expect(input).toHaveValue("Keep my draft");
  });

  it("opens a slash command palette and inserts the selected command", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/" } });

    const palette = screen.getByRole("listbox", { name: "Slash commands" });
    expect(palette).toBeInTheDocument();
    expect(palette).toHaveStyle({ maxHeight: "288px" });
    expect(screen.queryByRole("option", { name: /\/stop/i })).not.toBeInTheDocument();
    expect(screen.getByRole("option", { name: /\/history/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(input, { key: "Enter" });

    expect(input).toHaveValue("/history ");
    expect(screen.getByTestId("composer-slash-command")).toHaveTextContent("/history");
    expect(input.previousElementSibling?.textContent).toBe("/history ");
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.queryByRole("listbox", { name: "Slash commands" })).not.toBeInTheDocument();
  });

  it("offers stop autocomplete once the user starts typing it", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/sto" } });

    expect(screen.getByRole("option", { name: /\/stop/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(input, { key: "Enter" });

    expect(input).toHaveValue("/stop");
    expect(onSend).not.toHaveBeenCalled();
  });

  it("renders slash commands as direct actions with current status", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        modelLabel="deepseek-v4-pro"
        slashCommands={[
          {
            command: "/model",
            title: "Switch model preset",
            description: "Show or switch the active model preset.",
            icon: "brain",
            argHint: "[preset]",
            lifecycle: "side_channel",
            acceptsArgs: true,
          },
          COMMANDS[1],
        ]}
      />,
    );

    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "/" },
    });

    expect(screen.getByRole("option", { name: /Model deepseek-v4-pro/i })).toBeInTheDocument();
    expect(screen.getByText("Current")).toBeInTheDocument();
    expect(screen.getByText("/model [preset]")).toBeInTheDocument();
  });

  it("prioritizes stop as an immediate slash action while streaming", () => {
    const onStop = vi.fn();
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/" } });

    expect(screen.getByRole("option", { name: /Stop task/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onStop).toHaveBeenCalledTimes(1);
    expect(input).toHaveValue("");
    expect(window.localStorage.getItem("nanobot.webui.slashCommandRecents")).toBeNull();
  });

  it("orders recent slash commands first for the blank slash menu", () => {
    window.localStorage.setItem("nanobot.webui.slashCommandRecents", JSON.stringify(["/history"]));
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "/" },
    });

    expect(screen.getByRole("option", { name: /\/history/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    expect(screen.getByText("Recent")).toBeInTheDocument();
  });

  it("keeps keyboard-selected slash options visible while navigating", () => {
    const scrollIntoView = vi.fn();
    const originalScrollIntoView = HTMLElement.prototype.scrollIntoView;
    HTMLElement.prototype.scrollIntoView = scrollIntoView;

    try {
      render(
        <ThreadComposer
          onSend={vi.fn()}
          placeholder="Type your message..."
          slashCommands={Array.from({ length: 8 }, (_, index) => ({
            command: `/cmd-${index}`,
            title: `Command ${index}`,
            description: `Description ${index}`,
            icon: "activity",
            lifecycle: "side_channel",
            acceptsArgs: false,
          }))}
        />,
      );

      const input = screen.getByLabelText("Message input");
      fireEvent.change(input, { target: { value: "/" } });
      scrollIntoView.mockClear();

      fireEvent.keyDown(input, { key: "ArrowDown" });
      fireEvent.keyDown(input, { key: "ArrowDown" });

      expect(screen.getByRole("option", { name: /\/cmd-2/i })).toHaveAttribute(
        "aria-selected",
        "true",
      );
      expect(scrollIntoView).toHaveBeenLastCalledWith({ block: "nearest" });
    } finally {
      HTMLElement.prototype.scrollIntoView = originalScrollIntoView;
    }
  });

  it("opens the CLI app mention palette and inserts the selected app", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });

    const palette = screen.getByRole("listbox", { name: "Mentions" });
    expect(palette).toBeInTheDocument();
    expect(screen.getByRole("option", { name: /@gimp/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    expect(screen.queryByRole("option", { name: /@krita/i })).not.toBeInTheDocument();

    fireEvent.keyDown(input, { key: "ArrowDown" });
    expect(screen.getByRole("option", { name: /@blender/i })).toHaveAttribute(
      "aria-selected",
      "true",
    );
    fireEvent.keyDown(input, { key: "Enter" });

    expect(input).toHaveValue("@Blender ");
    expect(screen.getByTestId("composer-cli-mention-blender")).toHaveTextContent("@Blender");
    expect(screen.queryByTestId("composer-cli-app-tray")).not.toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.queryByRole("listbox", { name: "Mentions" })).not.toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("@blender", undefined, {
      cliApps: [{
        name: "blender",
        display_name: "Blender",
        category: "3d",
        entry_point: "cli-anything-blender",
        logo_url: null,
        brand_color: "#E87D0D",
      }],
    });
  });

  it("keeps keyboard-selected mention options visible while navigating", () => {
    const scrollIntoView = vi.fn();
    const originalScrollIntoView = HTMLElement.prototype.scrollIntoView;
    HTMLElement.prototype.scrollIntoView = scrollIntoView;

    try {
      render(
        <ThreadComposer
          onSend={vi.fn()}
          placeholder="Type your message..."
          cliApps={Array.from({ length: 8 }, (_, index) => ({
            name: `app-${index}`,
            display_name: `App ${index}`,
            category: "test",
            description: "Test app",
            requires: "",
            source: "harness",
            entry_point: `app-${index}`,
            install_supported: true,
            installed: true,
            available: true,
            status: "installed",
            logo_url: null,
            brand_color: "#111827",
            skill_installed: true,
          }))}
        />,
      );

      const input = screen.getByLabelText("Message input");
      fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });
      scrollIntoView.mockClear();

      fireEvent.keyDown(input, { key: "ArrowDown" });
      fireEvent.keyDown(input, { key: "ArrowDown" });

      expect(screen.getByRole("option", { name: /@app-2/i })).toHaveAttribute(
        "aria-selected",
        "true",
      );
      expect(scrollIntoView).toHaveBeenLastCalledWith({ block: "nearest" });
    } finally {
      HTMLElement.prototype.scrollIntoView = originalScrollIntoView;
    }
  });

  it("completes a CLI app mention with Tab and adds exactly one trailing space", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: "use @ble", selectionStart: 8 },
    });

    fireEvent.keyDown(input, { key: "Tab" });

    expect(input).toHaveValue("use @Blender ");
    expect(screen.getByTestId("composer-cli-mention-blender")).toHaveTextContent("@Blender");
  });

  it("shows configured MCP presets in the mention palette and submits metadata", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
        mcpPresets={MCP_PRESETS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: "use @bro", selectionStart: 8 },
    });

    expect(screen.getByRole("option", { name: /@browserbase/i })).toBeInTheDocument();
    expect(screen.queryByRole("option", { name: /@figma/i })).not.toBeInTheDocument();

    fireEvent.keyDown(input, { key: "Tab" });

    expect(input).toHaveValue("use @\u00a0Browserbase ");
    const mention = screen.getByTestId("composer-mcp-mention-browserbase");
    expect(mention.textContent).toBe("@\u00a0Browserbase");
    expect(mention).toHaveClass("font-normal");
    expect(mention).not.toHaveClass("font-[550]");

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("use @browserbase", undefined, {
      mcpPresets: [{
        name: "browserbase",
        display_name: "Browserbase",
        category: "browser",
        transport: "streamableHttp",
        status: "configured",
        configured: true,
        logo_url: "https://example.invalid/browserbase.svg",
        brand_color: "#111827",
      }],
    });
  });

  it.each(["typed", "pasted"])("attaches %s session handles without selecting a candidate", async (entry) => {
    const user = userEvent.setup();
    const onSend = vi.fn();
    const targets = [session("pricing", "Pricing", "", "bime"), session("notes", "Notes", "", "bari")];
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input");
    const text = "参考 @bime @bime @BARI";

    if (entry === "typed") await user.type(input, text);
    else {
      await user.click(input);
      await user.paste(text);
    }

    expect(screen.getAllByTestId("composer-session-mention-bime")).toHaveLength(2);
    expect(screen.getByTestId("composer-session-mention-bari")).toHaveTextContent("@BARI");
    await user.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(text, undefined, {
      sessionMentions: targets.map((target) => ({
        id: target.handle?.id,
        name: target.handle?.name,
        session_key: target.key,
        title: target.title,
      })),
    });
  });

  it.each(["typed", "pasted"])("recognizes %s session handles separated by punctuation without spaces", async (entry) => {
    const user = userEvent.setup();
    const onSend = vi.fn();
    const targets = [session("pricing", "Pricing", "", "bime"), session("notes", "Notes", "", "luma")];
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input");
    const text = "@bime、@luma,@luma";

    if (entry === "typed") await user.type(input, text);
    else {
      await user.click(input);
      await user.paste(text);
    }

    expect(screen.getByTestId("composer-session-mention-bime")).toHaveTextContent("@bime");
    expect(screen.getAllByTestId("composer-session-mention-luma")).toHaveLength(2);
    await user.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(text, undefined, {
      sessionMentions: targets.map((target) => ({
        id: target.handle?.id, name: target.handle?.name, session_key: target.key, title: target.title,
      })),
    });
  });

  it.each(["、", ",", ":"])("completes a session handle after %s without inserting a leading space", (separator) => {
    const onSend = vi.fn();
    const targets = [session("pricing", "Pricing", "", "bime"), session("notes", "Notes", "", "luma")];
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input");
    const text = `@bime${separator}@lu`;
    fireEvent.change(input, { target: { value: text, selectionStart: text.length } });

    expect(screen.getByRole("option", { name: /@luma/i })).toBeInTheDocument();
    fireEvent.keyDown(input, { key: "Tab" });
    expect(input).toHaveValue(`@bime${separator}@luma `);
    expect(screen.getByTestId("composer-session-mention-luma")).toHaveTextContent("@luma");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(`@bime${separator}@luma`, undefined, {
      sessionMentions: targets.map((target) => ({
        id: target.handle?.id, name: target.handle?.name, session_key: target.key, title: target.title,
      })),
    });
  });

  it("previews and drops a session after punctuation without changing the surrounding text", () => {
    const onSend = vi.fn();
    const targets = [session("pricing", "Pricing", "", "bime"), session("notes", "Notes", "", "luma")];
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@bime、", selectionStart: 6 } });
    const dataTransfer = { types: [SESSION_DRAG_TYPE], files: [], getData: () => targets[1].key };

    fireEvent.dragOver(input, { dataTransfer });
    expect(screen.getByTestId("composer-session-drag-preview")).toHaveTextContent("@luma");
    expect(input).toHaveValue("@bime、");
    fireEvent.drop(input, { dataTransfer });
    expect(input).toHaveValue("@bime、@luma ");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("@bime、@luma", undefined, {
      sessionMentions: targets.map((target) => ({
        id: target.handle?.id, name: target.handle?.name, session_key: target.key, title: target.title,
      })),
    });
  });

  it("leaves unknown handles, partial names, titles and embedded email or path handles as plain text", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} sessions={[session("pricing", "Pricing", "", "bime")]} />);
    const text = "@missing @bi @bimex @Pricing mail@bime word@bime /tmp/@bime";
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: text, selectionStart: text.length } });

    expect(screen.queryByTestId("composer-session-mention-bime")).not.toBeInTheDocument();
    expect(screen.queryByRole("listbox", { name: "Mentions" })).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(text, undefined, undefined);
  });

  it("updates session references when a typed handle is changed or removed", () => {
    const onSend = vi.fn();
    const target = session("notes", "Notes", "", "bari");
    render(<ThreadComposer onSend={onSend} sessions={[session("pricing", "Pricing", "", "bime"), target]} />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@bime @bari" } });
    expect(screen.getByTestId("composer-session-mention-bime")).toBeInTheDocument();
    fireEvent.change(input, { target: { value: "@bim @bari" } });

    expect(screen.queryByTestId("composer-session-mention-bime")).not.toBeInTheDocument();
    expect(screen.getByTestId("composer-session-mention-bari")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("@bim @bari", undefined, {
      sessionMentions: [{ id: target.handle?.id, name: "bari", session_key: target.key, title: "Notes" }],
    });
  });

  it("gives typed session handles the same priority over App and MCP names as the palette", () => {
    const onSend = vi.fn();
    const targets = [session("image-notes", "Image notes", "", "gimp"), session("browser-notes", "Browser notes", "", "bari")];
    render(<ThreadComposer onSend={onSend} sessions={targets} cliApps={CLI_APPS}
      mcpPresets={[{ ...MCP_PRESETS[0], name: "bari" }]} />);
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "@gimp @bari" } });

    expect(screen.getByTestId("composer-session-mention-gimp")).toBeInTheDocument();
    expect(screen.getByTestId("composer-session-mention-bari")).toBeInTheDocument();
    expect(screen.queryByTestId("composer-cli-mention-gimp")).not.toBeInTheDocument();
    expect(screen.queryByTestId("composer-mcp-mention-bari")).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("@gimp @bari", undefined, {
      sessionMentions: targets.map((target) => ({
        id: target.handle?.id, name: target.handle?.name, session_key: target.key, title: target.title,
      })),
    });
  });

  it("attaches persisted sessions through the shared mention palette", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        sessions={[session("pricing", "收费设计", "讨论云存储")]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: "参考 @收费", selectionStart: 6 },
    });

    expect(screen.getByRole("group", { name: "Nanobot conversations" })).toBeInTheDocument();
    expect(screen.getByRole("option", { name: /@收费设计/i })).toBeInTheDocument();
    fireEvent.keyDown(input, { key: "Tab" });

    expect(input).toHaveValue("参考 @收费设计 ");
    const mention = screen.getByTestId("composer-session-mention-收费设计");
    expect(mention).toHaveTextContent("@收费设计");
    expect(mention).toHaveClass("font-normal");
    expect(mention).not.toHaveClass("font-[550]");
    expect(mention.closest("a")).toBeNull();

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("参考 @收费设计", undefined, {
      sessionMentions: [{
        id: session("pricing", "收费设计").handle?.id,
        name: "收费设计",
        session_key: "websocket:pricing",
        title: "收费设计",
      }],
    });
  });

  it("turns a dropped sidebar session into the shared structured mention", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        sessions={[session("pricing", "收费设计", "讨论云存储")]}
      />,
    );

    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "Compare notes" } });
    input.setSelectionRange(7, 7);
    const dataTransfer = {
      types: [SESSION_DRAG_TYPE],
      effectAllowed: "copy",
      dropEffect: "none",
      files: [],
      getData: (type: string) => (
        type === SESSION_DRAG_TYPE ? "websocket:pricing" : ""
      ),
    };

    fireEvent.dragEnter(input, { dataTransfer });
    fireEvent.dragOver(input, { dataTransfer });

    expect(input).toHaveValue("Compare notes");
    expect(screen.getByTestId("composer-session-drag-preview"))
      .toHaveTextContent("@收费设计");

    fireEvent.dragEnd(document);
    expect(screen.queryByTestId("composer-session-drag-preview")).not.toBeInTheDocument();

    fireEvent.dragEnter(input, { dataTransfer });
    fireEvent.dragOver(input, { dataTransfer });

    fireEvent.drop(input, { dataTransfer });

    expect(input).toHaveValue("Compare @收费设计 notes");
    expect(screen.queryByTestId("composer-session-drag-preview")).not.toBeInTheDocument();
    expect(screen.getByTestId("composer-session-mention-收费设计"))
      .toHaveTextContent("@收费设计");

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("Compare @收费设计 notes", undefined, {
      sessionMentions: [{
        id: session("pricing", "收费设计").handle?.id,
        name: "收费设计",
        session_key: "websocket:pricing",
        title: "收费设计",
      }],
    });
  });

  it("rejects self-session drops that are unavailable to the composer", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        sessions={[]}
      />,
    );
    const input = screen.getByLabelText("Message input");
    const dataTransfer = {
      types: [SESSION_DRAG_TYPE],
      effectAllowed: "copyMove",
      dropEffect: "copy",
      files: [],
      getData: () => "websocket:current",
    };

    expect(fireEvent.dragEnter(input, { dataTransfer })).toBe(true);
    expect(fireEvent.dragOver(input, { dataTransfer })).toBe(true);
    expect(screen.queryByTestId("composer-session-drag-preview")).not.toBeInTheDocument();
  });

  it.each([" ", "、"])("rejects more than eight typed session references separated by %j without silently dropping them", (separator) => {
    const onSend = vi.fn();
    const targets = Array.from({ length: 9 }, (_, index) => session(`topic-${index}`, `Topic${index}`));
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input");
    const handles = targets.map((target) => `@${target.handle?.name}`);
    fireEvent.change(input, { target: { value: handles.join(separator) } });

    for (const target of targets) {
      expect(screen.getByTestId(`composer-session-mention-${target.handle?.name}`)).toBeInTheDocument();
    }
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("alert")).toHaveTextContent("A message can mention up to 8 chats");

    fireEvent.change(input, { target: { value: handles.slice(1).join(separator) } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend.mock.calls[0]?.[2].sessionMentions.map((mention: { session_key: string }) => mention.session_key))
      .toEqual(targets.slice(1).map((target) => target.key));
  });

  it.each(["palette", "drop"])("releases the eight-session limit for %s insertion when a mention is removed", (entry) => {
    const onSend = vi.fn();
    const targets = Array.from({ length: 9 }, (_, index) => session(`topic-${index}`, `Topic${index}`, "", `ref${index}x`));
    render(<ThreadComposer onSend={onSend} sessions={targets} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    const text = `${targets.slice(0, 8).map((target) => `@${target.handle?.name}`).join(" ")} @ref8`;
    fireEvent.change(input, { target: { value: text, selectionStart: text.length } });
    expect(screen.queryByRole("option", { name: /@ref8x/i })).not.toBeInTheDocument();
    const dataTransfer = { types: [SESSION_DRAG_TYPE], files: [], getData: () => targets[8].key };
    if (entry === "drop") {
      fireEvent.dragOver(input, { dataTransfer });
      expect(screen.queryByTestId("composer-session-drag-preview")).not.toBeInTheDocument();
      fireEvent.drop(input, { dataTransfer });
      expect(input).toHaveValue(text);
    }

    const replacement = input.value.replace("@ref0x ", "");
    fireEvent.change(input, { target: { value: replacement, selectionStart: replacement.length } });
    expect(screen.getByRole("option", { name: /@ref8x/i })).toBeInTheDocument();
    if (entry === "palette") fireEvent.keyDown(input, { key: "Tab" });
    else {
      input.setSelectionRange(replacement.lastIndexOf("@"), replacement.length);
      fireEvent.dragOver(input, { dataTransfer });
      expect(screen.getByTestId("composer-session-drag-preview")).toHaveTextContent("@ref8x");
      fireEvent.drop(input, { dataTransfer });
    }
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend.mock.calls[0]?.[2].sessionMentions.map((mention: { session_key: string }) => mention.session_key))
      .toEqual(targets.slice(1).map((target) => target.key));
  });

  it.each(["typed", "selected"])("keeps a %s session stable across refreshes and queued guidance", (entry) => {
    const onSend = vi.fn();
    const target = session("z-target", "Plan", "Original plan");
    const { rerender } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
        sessions={[target]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    if (entry === "typed") fireEvent.change(input, { target: { value: "@Plan " } });
    else {
      fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });
      fireEvent.keyDown(input, { key: "Tab" });
    }

    // The referenced chat was deleted and its handle reused by a new chat.
    const replacement = session("a-new", "New plan", "", "Plan");
    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
        sessions={[replacement]}
      />,
    );

    expect(screen.getByTestId("composer-session-mention-Plan")).toHaveTextContent("@Plan");
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.click(screen.getByRole("button", { name: "Send now" }));

    expect(onSend).toHaveBeenCalledWith("@Plan", undefined, {
      sessionMentions: [{
        id: session("z-target", "Plan").handle?.id,
        name: "Plan",
        session_key: "websocket:z-target",
        title: "Plan",
      }],
      continueActiveTurn: true,
    });
  });

  it.each(["palette", "drop"])("prevents %s insertion from retargeting a draft when a handle is reused", (entry) => {
    const onSend = vi.fn();
    const original = session("original", "Original plan", "", "bime");
    const replacement = session("replacement", "New plan", "", "bime");
    const composer = (target: ChatSummary) => <ThreadComposer onSend={onSend} sessions={[target]} />;
    const { rerender } = render(composer(original));
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@bime " } });
    rerender(composer(replacement));
    const dataTransfer = { types: [SESSION_DRAG_TYPE], files: [], getData: () => replacement.key };

    if (entry === "palette") {
      fireEvent.change(input, { target: { value: "@bime @bi", selectionStart: 9 } });
      expect(screen.queryByRole("option", { name: /@bime/i })).not.toBeInTheDocument();
    } else {
      fireEvent.dragOver(input, { dataTransfer });
      expect(screen.queryByTestId("composer-session-drag-preview")).not.toBeInTheDocument();
      fireEvent.drop(input, { dataTransfer });
      expect(input).toHaveValue("@bime ");
    }
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend.mock.calls[0]?.[2].sessionMentions).toEqual([{
      id: original.handle?.id, name: "bime", session_key: original.key, title: original.title,
    }]);

    if (entry === "palette") {
      fireEvent.change(input, { target: { value: "@bi", selectionStart: 3 } });
      expect(screen.getByRole("option", { name: /@bime/i })).toBeInTheDocument();
      fireEvent.keyDown(input, { key: "Tab" });
    } else {
      fireEvent.dragOver(input, { dataTransfer });
      expect(screen.getByTestId("composer-session-drag-preview")).toHaveTextContent("@bime");
      fireEvent.drop(input, { dataTransfer });
    }
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend.mock.calls[1]?.[2].sessionMentions).toEqual([{
      id: replacement.handle?.id, name: "bime", session_key: replacement.key, title: replacement.title,
    }]);
  });

  it("highlights slash commands alongside skills without changing native edits or sending", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} slashCommands={COMMANDS} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    const text = "/history $workflow 中文 English";
    fireEvent.change(input, { target: { value: text, selectionStart: text.length } });

    const command = screen.getByTestId("composer-slash-command");
    const skill = screen.getByTestId("composer-skill-reference-workflow");
    expect(command).toHaveTextContent("/history");
    expect(command.className).toBe(skill.className);
    expect(command.getAttribute("style")).toBe(skill.getAttribute("style"));
    expect(input.previousElementSibling).toHaveAttribute("aria-hidden", "true");
    expect(input.previousElementSibling?.textContent).toBe(text);

    input.setSelectionRange(1, 4);
    const setData = vi.fn();
    fireEvent.copy(input, { clipboardData: { setData } });
    expect(setData).toHaveBeenCalledWith("text/plain", "his");
    fireEvent.cut(input, { clipboardData: { setData } });
    expect(input).toHaveValue("/tory $workflow 中文 English");
    expect(screen.queryByTestId("composer-slash-command")).not.toBeInTheDocument();
    fireEvent.keyDown(input, { key: "z", ctrlKey: true });
    expect(input).toHaveValue(text);
    expect(input.selectionStart).toBe(1);
    expect(input.selectionEnd).toBe(4);
    expect(screen.getByTestId("composer-slash-command")).toHaveTextContent("/history");

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(text, undefined, { sideChannel: true });
  });

  it("highlights literal skill references while preserving partial edits, clipboard text and sending", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    const text = "like $workflow 与 $skill-creator,$";
    fireEvent.change(input, { target: { value: text, selectionStart: text.length } });

    expect(screen.getByTestId("composer-skill-reference-workflow")).toHaveTextContent(/^\$workflow$/);
    expect(screen.getByTestId("composer-skill-reference-skill-creator")).toHaveTextContent(/^\$skill-creator$/);
    expect(input).toHaveValue(text);
    expect(input.previousElementSibling).toHaveAttribute("aria-hidden", "true");
    expect(input.previousElementSibling?.textContent).toBe(text);

    const start = text.indexOf("workflow") + 1;
    const end = start + 4;
    input.setSelectionRange(start, end);
    const setData = vi.fn();
    fireEvent.copy(input, { clipboardData: { setData } });
    expect(setData).toHaveBeenCalledWith("text/plain", text.slice(start, end));
    fireEvent.cut(input, { clipboardData: { setData } });
    expect(input).toHaveValue(text.slice(0, start) + text.slice(end));
    fireEvent.keyDown(input, { key: "z", ctrlKey: true });
    expect(input).toHaveValue(text);
    expect(input.selectionStart).toBe(start);
    expect(input.selectionEnd).toBe(end);

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(text, undefined, undefined);
  });

  it("highlights only the leading bang with the skill-reference color and preserves literal command text", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "$workflow " } });
    const referenceColor = screen.getByTestId("composer-skill-reference-workflow").style.color;
    const command = '  !echo "hello! $workflow @typography"\nWrite-Output done';
    fireEvent.change(input, { target: { value: command } });
    const bang = screen.getByTestId("composer-shell-prefix");
    expect(bang).toHaveTextContent(/^!$/);
    expect(bang.style.color).toBe(referenceColor);
    expect(input.previousElementSibling).toHaveAttribute("aria-hidden", "true");
    expect(input.previousElementSibling?.textContent).toBe(command);
    expect(input).toHaveValue(command);
    fireEvent.keyDown(input, { key: "Enter" });
    expect(onSend).toHaveBeenCalledWith(command.trim(), undefined, { sideChannel: true, userShell: true });
  });

  it.each(["", "/history "])("mirrors inline references during composition without submitting the IME confirmation: %s", (prefix) => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} slashCommands={COMMANDS} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: `${prefix}$workflow ` } });
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: `${prefix}$workflow zhong` } });
    if (prefix) expect(screen.getByTestId("composer-slash-command")).toHaveTextContent("/history");
    expect(screen.getByTestId("composer-skill-reference-workflow")).toHaveTextContent(/^\$workflow$/);
    expect(input.previousElementSibling?.textContent).toBe(input.value);
    expect(input.previousElementSibling).toHaveClass("z-20");
    fireEvent.keyDown(input, { key: "Enter", isComposing: true });
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.change(input, { target: { value: `${prefix}$workflow 中` } });
    fireEvent.compositionEnd(input, { data: "中" });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(`${prefix}$workflow 中`, undefined, prefix ? { sideChannel: true } : undefined);
  });

  it("opens skills only from a $ reference and prioritizes the skill name", () => {
    const skillName = "arxiv-intelligence-filter";
    render(
        <ThreadComposer
          onSend={vi.fn()}
          placeholder="Type your message..."
          skills={[
            {
              name: skillName,
              description: "Fetch and summarize the latest AI research papers every day",
              source: "builtin",
              enabled: true,
              available: true,
            },
            {
              name: "arxiv-disabled",
              description: "Disabled research workflow",
              source: "builtin",
              enabled: false,
              available: true,
            },
            {
              name: "arxiv-unavailable",
              description: "Unavailable research workflow",
              source: "builtin",
              enabled: true,
              available: false,
            },
          ]}
          slashCommands={COMMANDS}
        />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/git", selectionStart: 4 } });
    expect(screen.queryByRole("listbox", { name: "Slash commands" })).not.toBeInTheDocument();

    fireEvent.change(input, { target: { value: "please use $arxiv", selectionStart: 17 } });

    const palette = screen.getByRole("listbox", { name: "Slash commands" });
    const option = within(palette).getByRole("option", { name: new RegExp(skillName, "i") });
    const name = within(option).getByText(skillName);
    expect(name).not.toHaveClass("truncate");
    expect(within(option).queryByText(`$${skillName}`)).not.toBeInTheDocument();
    expect(within(palette).queryByText("arxiv-disabled")).not.toBeInTheDocument();
    expect(within(palette).queryByText("arxiv-unavailable")).not.toBeInTheDocument();
    expect(within(palette).queryByText("/model")).not.toBeInTheDocument();

    fireEvent.keyDown(input, { key: "Tab" });

    expect(input).toHaveValue(`please use $${skillName} `);
    expect(screen.getByTestId(`composer-skill-reference-${skillName}`))
      .toHaveTextContent(`$${skillName}`);
  });

  it("ranks skill name matches ahead of earlier description matches", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        skills={[
          {
            name: "skill-creator",
            description: "Create or update AgentSkills",
            source: "builtin",
            available: true,
          },
          {
            name: "setup-update",
            description: "Configure upgrades",
            source: "builtin",
            available: true,
          },
          {
            name: "upload-files",
            description: "Transfer local files",
            source: "builtin",
            available: true,
          },
          {
            name: "up",
            description: "Exact match",
            source: "workspace",
            available: true,
          },
        ]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "$up", selectionStart: 3 } });

    const options = within(screen.getByRole("listbox", { name: "Slash commands" }))
      .getAllByRole("option");
    expect(options.map((option) => option.textContent)).toEqual([
      "upExact match",
      "upload-filesTransfer local files",
      "setup-updateConfigure upgrades",
      "skill-creatorCreate or update AgentSkills",
    ]);
  });

  it("keeps a recently selected skill visible at the top of the blank skill menu", () => {
    const skills = Array.from({ length: 9 }, (_, index) => ({
      name: `skill-${index}`,
      description: `Skill ${index}`,
      source: "builtin",
      available: true,
    }));
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        skills={skills}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "$skill-8", selectionStart: 8 } });
    fireEvent.keyDown(input, { key: "Tab" });
    fireEvent.change(input, { target: { value: "$", selectionStart: 1 } });

    const options = within(screen.getByRole("listbox", { name: "Slash commands" }))
      .getAllByRole("option");
    expect(options).toHaveLength(8);
    expect(options[0]).toHaveTextContent("skill-8");
    expect(options[0]).toHaveTextContent("Recent");
  });

  it("shows session handles without an icon and preserves app icons after their identifiers", () => {
    render(<ThreadComposer
      onSend={vi.fn()}
      sessions={[session("pricing", "Pricing", "", "bime")]}
      cliApps={CLI_APPS}
      mcpPresets={MCP_PRESETS}
    />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });

    const conversation = screen.getByRole("option", { name: /@bime Pricing/i });
    const app = screen.getByRole("option", { name: /@gimp GIMP/i });
    const mcp = screen.getByRole("option", { name: /@browserbase Browserbase/i });
    expect(conversation.children[0]).toHaveTextContent("@bime");
    expect(conversation.children[1]).toHaveTextContent("Pricing");
    expect(conversation.querySelector('[data-product-icon="conversation"]')).not.toBeInTheDocument();
    expect(app.children[0]).toHaveTextContent("@gimp");
    expect(app.children[1].querySelector("img")).toHaveAttribute("src", CLI_APPS[0].logo_url);
    expect(app.children[1]).toHaveTextContent("GIMP");
    expect(mcp.children[0]).toHaveTextContent("@browserbase");
    expect(mcp.children[1].querySelector("img")).toHaveAttribute("src", MCP_PRESETS[0].logo_url);
    expect(mcp.children[1]).toHaveTextContent("Browserbase");
  });

  it("shows right-side source badges so users can distinguish CLI apps from MCP servers", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
        mcpPresets={MCP_PRESETS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@", selectionStart: 1 } });

    expect(screen.queryByText("CLI Apps")).not.toBeInTheDocument();
    expect(screen.queryByText("MCP servers")).not.toBeInTheDocument();
    const gimp = screen.getByRole("option", { name: /@gimp GIMP .* CLI/i });
    const browserbase = screen.getByRole("option", { name: /@browserbase Browserbase .* MCP/i });
    expect(gimp).toHaveClass("touch-target");
    expect(browserbase).toHaveClass("touch-target");
    expect(within(gimp).getByText("CLI")).toBeInTheDocument();
    expect(within(browserbase).getByText("MCP")).toBeInTheDocument();
    expect(within(gimp).getByText("@gimp")).toBeInTheDocument();
    expect(within(browserbase).getByText("@browserbase")).toBeInTheDocument();
  });

  it("does not duplicate the next word separator when completing a CLI app mention", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: "use @ble tonight", selectionStart: 8 },
    });

    fireEvent.keyDown(input, { key: "Tab" });

    expect(input).toHaveValue("use @Blender tonight");
  });

  it("keeps literal mixed-script spacing in both composer input layers", () => {
    render(<ThreadComposer onSend={vi.fn()} cliApps={CLI_APPS} />);
    const input = screen.getByLabelText("Message input");
    const value = "定位原因, 提 @gimp issue, i并提 $workflow";
    fireEvent.change(input, { target: { value, selectionStart: value.length } });

    const display = "定位原因, 提 @\u00a0GIMP issue, i并提 $workflow";
    const overlay = input.previousElementSibling;
    expect(input).toHaveValue(display);
    expect(overlay).toHaveAttribute("aria-hidden", "true");
    expect(overlay?.textContent).toBe(display);
    expect(input).toHaveClass("[text-autospace:no-autospace]");
    expect(overlay).toHaveClass("[text-autospace:no-autospace]");
    expect(screen.getByTestId("composer-skill-reference-workflow")).toHaveTextContent("$workflow");
  });

  it("renders a CLI app mention logo inline without moving the text cursor slot", () => {
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        cliApps={CLI_APPS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: "meeting in @gimp", selectionStart: 16 },
    });

    expect(input).toHaveValue("meeting in @\u00a0GIMP");
    const token = screen.getByTestId("composer-cli-mention-gimp");
    expect(token.textContent).toBe("@\u00a0GIMP");
    expect(token).toHaveClass("font-normal");
    expect(token).not.toHaveClass("font-[550]");
    expect(token.className).not.toContain("zoom-in");
    expect(token.className).not.toContain("px-");
    expect(token.className).not.toContain("mx-");
    expect(token).toHaveClass("text-foreground");
    expect(token.style.textShadow).toBe("");
    expect(screen.queryByTestId("composer-cli-app-tray")).not.toBeInTheDocument();
    const logo = screen.getByTestId("composer-cli-mention-logo-gimp");
    expect(logo.className).toContain("top-1/2");
    expect(logo.className).toContain("left-0");
    expect(logo.className).not.toContain("-top-");
    expect(logo).toHaveClass("h-[0.9em]", "w-[0.9em]", "rounded-[0.25em]");
    // The shared text projection reserves the gap; no CSS margin may shift the caret.
    expect(logo.parentElement).toHaveTextContent("@");
    expect(logo.parentElement).toHaveClass("inline");
    expect(logo.parentElement).not.toHaveClass("inline-block");
    expect(logo.parentElement?.className).not.toMatch(/(?:^|\s)(?:w-|m[rlx]-|p[rlx]-)/);
  });

  it.each(["cli", "mcp"] as const)("emphasizes the %s brand without changing composer text metrics", (kind) => {
    render(<ThreadComposer
      onSend={vi.fn()}
      cliApps={kind === "cli" ? [{ ...CLI_APPS[0], name: "linear", display_name: "Linear" }] : []}
      mcpPresets={kind === "mcp" ? [{ ...MCP_PRESETS[0], name: "linear", display_name: "Linear" }] : []}
    />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@linear 帮我查看", selectionStart: 12 } });
    const token = screen.getByTestId(`composer-${kind}-mention-linear`);
    const name = token.lastElementChild!;
    expect(name).toHaveTextContent("Linear");
    expect(name).toHaveClass("[-webkit-text-stroke:0.4px_currentColor]");
    expect(token).toHaveClass("font-normal");
    expect(token.firstElementChild).not.toHaveClass("[-webkit-text-stroke:0.4px_currentColor]");
    expect(input).toHaveValue("@\u00a0Linear 帮我查看");
    expect(input).not.toHaveClass("font-semibold");
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: "@\u00a0Linear 帮我查看n" } });
    expect(token.lastElementChild).toBe(name);
    expect(name).toHaveClass("[-webkit-text-stroke:0.4px_currentColor]");
  });

  it("uses the theme foreground when an installed CLI app has no brand metadata", () => {
    const mention = "@obsidian-agent-cli";
    const app: CliAppInfo = {
      name: "obsidian-agent-cli",
      display_name: "Obsidian CLI",
      category: "productivity",
      description: "Obsidian automation",
      requires: "",
      source: "local",
      entry_point: "obsidian-agent",
      install_supported: true,
      installed: true,
      available: true,
      status: "installed",
      logo_url: null,
      brand_color: null,
      skill_installed: true,
    };
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Type your message..."
        cliApps={[app]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, {
      target: { value: mention, selectionStart: mention.length },
    });

    const token = screen.getByTestId("composer-cli-mention-obsidian-agent-cli");
    expect(token).toHaveClass("text-foreground");
  });

  it.each([
    ["linear", "Linear"], ["drawio", "Draw.io"], ["google-drive", "Google Drive"],
    ["iterm2", "iTerm2"], ["gimp", "GIMP"], ["1password", "1Password"],
    ["local", "本地应用"], ["fallback", "  "],
  ])("shows %s's brand in the input and sends its identifier", (name, displayName) => {
    const onSend = vi.fn();
    const app = { ...CLI_APPS[0], name, display_name: displayName };
    render(<ThreadComposer onSend={onSend} cliApps={[app]} />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: `请用 @${name} 帮我`, selectionStart: name.length + 5 } });
    const label = displayName.trim() || name;
    expect(input).toHaveValue(`请用 @\u00a0${label} 帮我`);
    expect(screen.getByTestId(`composer-cli-mention-${name}`).textContent).toBe(`@\u00a0${label}`);
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith(`请用 @${name} 帮我`, undefined, {
      cliApps: [expect.objectContaining({ name, display_name: displayName })],
    });
  });

  it("keeps multiple long mentions intact while editing, copying, cutting and undoing", async () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} cliApps={[
      { ...CLI_APPS[0], name: "drive", display_name: "Google Drive" },
      { ...CLI_APPS[1], name: "drawio", display_name: "Draw.io" },
    ]} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@drive @drawio" } });
    input.setSelectionRange(14, 14);
    await userEvent.type(input, " hello", { skipClick: true });
    expect(input).toHaveValue("@\u00a0Google Drive hello @Draw.io");
    input.setSelectionRange(0, 14);
    const setData = vi.fn();
    fireEvent.copy(input, { clipboardData: { setData } });
    expect(setData).toHaveBeenCalledWith("text/plain", "@drive");
    fireEvent.cut(input, { clipboardData: { setData } });
    expect(input).toHaveValue(" hello @Draw.io");
    fireEvent.keyDown(input, { key: "z", metaKey: true });
    expect(input).toHaveValue("@\u00a0Google Drive hello @Draw.io");
    fireEvent.keyDown(input, { key: "z", metaKey: true, shiftKey: true });
    expect(input).toHaveValue(" hello @Draw.io");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("hello @drawio", undefined, {
      cliApps: [expect.objectContaining({ name: "drawio" })],
    });
  });

  it("deletes a brand mention as a unit and restores it on undo", async () => {
    render(<ThreadComposer onSend={vi.fn()} mcpPresets={[
      { ...MCP_PRESETS[0], name: "drive", display_name: "Google Drive" },
    ]} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@drive!" } });
    input.setSelectionRange(14, 14);
    await userEvent.keyboard("{Backspace}");
    expect(input).toHaveValue("!");
    fireEvent.keyDown(input, { key: "z", ctrlKey: true });
    expect(input).toHaveValue("@\u00a0Google Drive!");
  });

  it("does not interrupt Chinese composition or submit on an IME confirmation", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} cliApps={[
      { ...CLI_APPS[0], name: "drive", display_name: "Google Drive" },
    ]} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@drive " } });
    const logo = screen.getByTestId("composer-cli-mention-logo-drive");
    fireEvent.compositionStart(input);
    expect(screen.getByTestId("composer-cli-mention-logo-drive")).toBe(logo);
    fireEvent.change(input, { target: { value: "@\u00a0Google Drive 中", selectionStart: 16 } });
    expect(input).toHaveValue("@\u00a0Google Drive 中");
    expect(input).toHaveClass("text-transparent");
    expect(input.previousElementSibling).toHaveClass("z-20");
    expect(screen.getByTestId("composer-cli-mention-logo-drive")).toBe(logo);
    expect(input.previousElementSibling?.textContent).toBe(input.value);
    fireEvent.keyDown(input, { key: "Enter", isComposing: true });
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.compositionEnd(input, { data: "中" });
    expect(input).toHaveValue("@\u00a0Google Drive 中");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("@drive 中", undefined, {
      cliApps: [expect.objectContaining({ name: "drive" })],
    });
  });

  it("does not remove a mention when composition is canceled inside its label", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} mcpPresets={[
      { ...MCP_PRESETS[0], name: "drive", display_name: "Google Drive" },
    ]} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@drive next" } });
    input.setSelectionRange(4, 4);
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: "@\u00a0Gonogle Drive next", selectionStart: 5 } });
    fireEvent.change(input, { target: { value: "@\u00a0Google Drive next", selectionStart: 4 } });
    fireEvent.compositionEnd(input, { data: "" });
    expect(input).toHaveValue("@\u00a0Google Drive next");
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("@drive next", undefined, {
      mcpPresets: [expect.objectContaining({ name: "drive" })],
    });
  });

  it("clears mention editing and undo state when switching sessions during composition", () => {
    const props = { onSend: vi.fn(), cliApps: CLI_APPS };
    const { rerender } = render(<ThreadComposer {...props} pendingQueueKey="chat-a" />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@gimp " } });
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: "@\u00a0GIMP 草稿" } });
    rerender(<ThreadComposer {...props} pendingQueueKey="chat-b" />);
    expect(input).toHaveValue("");
    fireEvent.compositionEnd(input, { data: "草稿" });
    fireEvent.keyDown(input, { key: "z", metaKey: true });
    expect(input).toHaveValue("");
  });

  it("mirrors the trailing empty line and scroll offset of a decorated textarea", () => {
    render(<ThreadComposer onSend={vi.fn()} cliApps={CLI_APPS} />);
    const input = screen.getByLabelText("Message input") as HTMLTextAreaElement;
    fireEvent.change(input, { target: { value: "@gimp\n" } });
    const overlay = input.previousElementSibling as HTMLElement;
    expect(overlay.textContent).toBe("@\u00a0GIMP\n\u200b");
    expect(input).toHaveClass("block");
    input.scrollTop = 80;
    fireEvent.scroll(input);
    expect(overlay.scrollTop).toBe(80);
  });

  it("opens the slash command palette downward when there is more room below", async () => {
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockReturnValue(
      rect({ top: 40, bottom: 160, width: 800, height: 120 }),
    );
    Object.defineProperty(window, "innerHeight", {
      value: 330,
      configurable: true,
    });
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        slashCommands={COMMANDS}
        variant="hero"
      />,
    );
    const input = screen.getByLabelText("Message input");

    fireEvent.change(input, { target: { value: "/" } });

    await waitFor(() => {
      const palette = screen.getByRole("listbox", { name: "Slash commands" });
      expect(palette.className).toContain("top-full");
      expect(palette).toHaveStyle({ maxHeight: "162px" });
    });
  });

  it("keeps the slash command palette above a keyboard-constrained visual viewport", async () => {
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockReturnValue(
      rect({ top: 120, bottom: 220, width: 390, height: 100 }),
    );
    Object.defineProperty(window, "innerHeight", {
      value: 800,
      configurable: true,
    });
    stubVisualViewport({ height: 300 });
    render(
      <ThreadComposer
        onSend={vi.fn()}
        placeholder="Ask anything..."
        slashCommands={COMMANDS}
      />,
    );
    const input = screen.getByLabelText("Message input");

    fireEvent.change(input, { target: { value: "/" } });

    await waitFor(() => {
      const palette = screen.getByRole("listbox", { name: "Slash commands" });
      expect(palette.className).toContain("bottom-full");
      expect(palette).toHaveStyle({ maxHeight: "112px" });
    });
  });

  it.each(["/", "@"]) ("fits %s suggestions in the app frame while iOS pans the keyboard", (trigger) => {
    stubVisualViewport({ height: 396, offsetTop: 350 });
    let formTop = 274;
    let frameHeight = 396;
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockImplementation(
      () => rect({ top: formTop, width: 388, height: 112 }),
    );
    vi.spyOn(HTMLDivElement.prototype, "getBoundingClientRect").mockImplementation(
      () => rect({ top: 0, width: 420, height: frameHeight }),
    );
    render(
      <div id="root" className="visual-viewport" style={{ overflowY: "hidden" }}>
        <ThreadComposer onSend={vi.fn()} slashCommands={COMMANDS} cliApps={CLI_APPS} />
      </div>,
    );
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: trigger, selectionStart: 1 } });
    const palette = screen.getByRole("listbox");
    expect(palette).toHaveClass("bottom-full");
    expect(palette).toHaveStyle({ maxHeight: "266px" });

    // Keyboard dismissal moves the composer; keep measuring the same frame.
    formTop = 620;
    frameHeight = 746;
    Object.assign(window.visualViewport!, { height: 746, offsetTop: 0 });
    act(() => window.visualViewport!.dispatchEvent(new Event("resize")));
    expect(palette).toHaveStyle({ maxHeight: "288px" });
    fireEvent.keyDown(input, { key: "Enter" });
    expect(screen.queryByRole("listbox")).not.toBeInTheDocument();
    expect(input).not.toHaveValue(trigger);
  });

  it.each(["/", "@"]) ("keeps %s selectable beside the input in a short landscape frame", (trigger) => {
    stubVisualViewport({ height: 128, offsetTop: 208 });
    let landscape = true;
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockImplementation(
      () => rect({ top: landscape ? 44 : 274, width: landscape ? 744 : 388, height: 112 }),
    );
    vi.spyOn(HTMLDivElement.prototype, "getBoundingClientRect").mockImplementation(function (this: HTMLDivElement) {
      return this.id === "root"
        ? rect({ top: 0, width: landscape ? 776 : 420, height: landscape ? 128 : 396 })
        : rect({ top: landscape ? 44 : 0, width: landscape ? 776 : 420, height: landscape ? 84 : 396 });
    });
    const onSend = vi.fn();
    render(
      <div id="root" className="visual-viewport short-visual-viewport" style={{ overflowY: "hidden" }}>
        <div style={{ overflowY: "auto" }}>
          <ThreadComposer onSend={onSend} slashCommands={COMMANDS} cliApps={CLI_APPS} />
        </div>
      </div>,
    );
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: trigger, selectionStart: 1 } });
    const palette = screen.getByRole("listbox");
    expect(palette).toHaveClass("col-start-2");
    expect(palette).not.toHaveClass("absolute");
    expect(palette).toHaveStyle({ maxHeight: "84px" });
    expect(input.closest("form")).toHaveAttribute("data-palette-beside", "true");

    landscape = false;
    document.getElementById("root")!.classList.remove("short-visual-viewport");
    Object.assign(window.visualViewport!, { height: 396, offsetTop: 350 });
    act(() => window.visualViewport!.dispatchEvent(new Event("resize")));
    expect(palette).toHaveClass("bottom-full");
    expect(palette).toHaveStyle({ maxHeight: "266px" });
    expect(input).toHaveValue(trigger);
    fireEvent.mouseDown(screen.getAllByRole("option")[0]!);
    expect(screen.queryByRole("listbox")).not.toBeInTheDocument();
    expect(input.closest("form")).not.toHaveAttribute("data-palette-beside");
    expect(onSend).not.toHaveBeenCalled();
  });

  it.each([false, true])("uses visual bounds outside fitting (pinch zoom: %s)", (zoomed) => {
    stubVisualViewport({ height: 300, offsetTop: 100 });
    if (zoomed) Object.assign(window.visualViewport!, { scale: 2 });
    vi.spyOn(HTMLFormElement.prototype, "getBoundingClientRect").mockReturnValue(
      rect({ top: 220, width: 390, height: 100 }),
    );
    render(
      <div id="root" className={zoomed ? "visual-viewport" : undefined}>
        <ThreadComposer onSend={vi.fn()} slashCommands={COMMANDS} />
      </div>,
    );
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "/" } });
    expect(screen.getByRole("listbox")).toHaveStyle({ maxHeight: "112px" });
    expect(screen.getByRole("listbox")).toHaveClass("bottom-full");
  });

  it("dismisses the slash command palette on outside click", () => {
    render(
      <div>
        <button type="button">outside</button>
        <ThreadComposer
          onSend={vi.fn()}
          placeholder="Type your message..."
          slashCommands={COMMANDS}
        />
      </div>,
    );

    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "/" },
    });
    expect(screen.getByRole("listbox", { name: "Slash commands" })).toBeInTheDocument();

    fireEvent.pointerDown(screen.getByRole("button", { name: "outside" }));

    expect(screen.queryByRole("listbox", { name: "Slash commands" })).not.toBeInTheDocument();
  });

  it("keeps image generation mode out of the composer chrome", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

    expect(screen.queryByRole("button", { name: "Image mode" })).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: "Image aspect ratio" })).not.toBeInTheDocument();

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "Draw a friendly robot" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("Draw a friendly robot", undefined, undefined);
  });

  it.each(["!pwd", "  ! pwd  ", "!Write-Output first\nWrite-Output second", "!"])("runs bang input directly without a configured model: %s", (command) => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} modelNeedsSetup />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: command } });
    fireEvent.click(screen.getByRole("button", { name: "Run Shell command" }));

    expect(onSend).toHaveBeenCalledWith(command.trim(), undefined, { sideChannel: true, userShell: true });
    expect(input).toHaveValue("");
  });

  it("keeps bang commands separate from pending guidance and the active turn", async () => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    const { rerender } = render(<ThreadComposer onSend={onSend} onStop={onStop} isStreaming />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "waiting guidance" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.change(input, { target: { value: "!pwd" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledOnce();
    expect(onSend).toHaveBeenCalledWith("!pwd", undefined, { sideChannel: true, userShell: true });
    expect(within(screen.getByRole("group", { name: "Waiting to send" })).getByText("waiting guidance")).toBeInTheDocument();
    expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();
    expect(onStop).not.toHaveBeenCalled();

    rerender(<ThreadComposer onSend={onSend} onStop={onStop} isStreaming={false} />);
    await waitFor(() => expect(onSend).toHaveBeenCalledTimes(2));
    expect(onSend).toHaveBeenLastCalledWith("waiting guidance");
  });

  it.each(["!echo @gimp", "!echo $weather"])("keeps bang arguments literal instead of opening a mention or skill menu: %s", (command) => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} cliApps={CLI_APPS} skills={[{ name: "weather", description: "Weather", source: "builtin", available: true }]} />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: command, selectionStart: command.length } });
    expect(input).toHaveValue(command);
    fireEvent.keyDown(input, { key: "Enter" });
    expect(onSend).toHaveBeenCalledWith(command, undefined, { sideChannel: true, userShell: true });
  });

  it("keeps exclamation marks inside ordinary messages on the chat path", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} />);
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "Please explain !pwd" } });
    fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });
    expect(onSend).toHaveBeenCalledWith("Please explain !pwd", undefined, undefined);
  });

  it("retains a bang draft when delivery is rejected without retrying it", async () => {
    const onSend = vi.fn().mockRejectedValue(new Error("Shell send rejected"));
    const { rerender } = render(<ThreadComposer onSend={onSend} />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "!pwd" } });
    fireEvent.keyDown(input, { key: "Enter" });
    await waitFor(() => expect(screen.getByRole("alert")).toHaveTextContent("Shell send rejected"));
    expect(input).toHaveValue("!pwd");
    rerender(<ThreadComposer onSend={onSend} isStreaming={false} />);
    expect(onSend).toHaveBeenCalledOnce();
    expect(onSend).toHaveBeenCalledWith("!pwd", undefined, { sideChannel: true, userShell: true });
  });

  it("rejects attachments on bang input without losing the draft or attachment", async () => {
    const onSend = vi.fn();
    const { container } = render(<ThreadComposer onSend={onSend} />);
    fireEvent.change(container.querySelector('input[type="file"]')!, {
      target: { files: [new File(["image"], "photo.png", { type: "image/png" })] },
    });
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "!pwd" } });
    await waitFor(() => expect(screen.getByRole("button", { name: "Run Shell command" })).toBeEnabled());
    fireEvent.keyDown(input, { key: "Enter" });
    expect(screen.getByRole("alert")).toHaveTextContent("Remove attachments and quoted text before running a command.");
    expect(onSend).not.toHaveBeenCalled();
    expect(input).toHaveValue("!pwd");
    expect(screen.getByRole("button", { name: "Remove attachment" })).toHaveAttribute("aria-description", "photo.png");
  });

  it("rejects quoted context on bang input without clearing it", () => {
    const onSend = vi.fn();
    const onQuotedContextChange = vi.fn();
    render(<ThreadComposer onSend={onSend} quotedContext="keep this quote" onQuotedContextChange={onQuotedContextChange} />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "!pwd" } });
    fireEvent.keyDown(input, { key: "Enter" });
    expect(screen.getByRole("alert")).toHaveTextContent("Remove attachments and quoted text before running a command.");
    expect(input).toHaveValue("!pwd");
    expect(onSend).not.toHaveBeenCalled();
    expect(onQuotedContextChange).not.toHaveBeenCalled();
  });

  it("marks known slash commands as side-channel sends", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

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

    expect(onSend).toHaveBeenCalledWith("/history", undefined, { sideChannel: true });
  });

  it("does not infer side-channel behavior before command metadata loads", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
      />,
    );

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

    expect(onSend).toHaveBeenCalledWith("/status", undefined, undefined);
  });

  it("sends a possible stop command without waiting when command metadata is unavailable", () => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    render(<ThreadComposer onSend={onSend} onStop={onStop} isStreaming />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/stop" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledWith("/stop", undefined, { continueActiveTurn: true });
    expect(onStop).not.toHaveBeenCalled();
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it("marks new chat commands as side-channel sends that finalize the active turn", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={[
          {
            command: "/new",
            title: "New chat",
            description: "Reset this chat and start a fresh conversation.",
            icon: "square-pen",
            lifecycle: "finalize_active_turn",
            acceptsArgs: false,
          },
        ]}
      />,
    );

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

    expect(onSend).toHaveBeenCalledWith(
      "/new",
      undefined,
      { sideChannel: true, finalizeActiveTurn: true },
    );
  });

  it("does not classify exact-only slash commands with arguments", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={[
          {
            command: "/new",
            title: "New chat",
            description: "Reset this chat and start a fresh conversation.",
            icon: "square-pen",
            lifecycle: "finalize_active_turn",
            acceptsArgs: false,
          },
        ]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/new with a title" } });
    expect(screen.queryByTestId("composer-slash-command")).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("/new with a title", undefined, undefined);
  });

  it("routes a manually submitted stop command through the stop handler", () => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
        slashCommands={COMMANDS}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/stop" } });
    fireEvent.keyDown(input, { key: "Escape" });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onStop).toHaveBeenCalledTimes(1);
    expect(onSend).not.toHaveBeenCalled();
  });

  it("keeps goal task commands on the normal agent turn path", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={[
          {
            command: "/goal",
            title: "Start long-running goal",
            description: "Tell the agent to treat the request as a long-running goal.",
            icon: "activity",
            argHint: "<goal>",
            lifecycle: "agent_turn_with_args",
            acceptsArgs: true,
          },
        ]}
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "/goal fix the release blocker" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith(
      "/goal fix the release blocker",
      undefined,
      undefined,
    );
  });

  it("keeps goal usage commands on the side-channel path", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        placeholder="Type your message..."
        slashCommands={[
          {
            command: "/goal",
            title: "Start long-running goal",
            description: "Tell the agent to treat the request as a long-running goal.",
            icon: "activity",
            argHint: "<goal>",
            lifecycle: "agent_turn_with_args",
            acceptsArgs: true,
          },
        ]}
      />,
    );

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

    expect(onSend).toHaveBeenCalledWith("/goal", undefined, { sideChannel: true });
  });

  it("shows a stop button while streaming", () => {
    const onStop = vi.fn();
    render(
      <ThreadComposer
        onSend={vi.fn()}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    fireEvent.click(screen.getByRole("button", { name: "Stop response" }));

    expect(onStop).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("button", { name: "Send message" })).not.toBeInTheDocument();
  });

  it("switches the primary action from Stop to Send while streaming once the user types", () => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    expect(screen.getByRole("button", { name: "Stop response" })).toBeInTheDocument();

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "one more thing: " } });

    expect(screen.queryByRole("button", { name: "Stop response" })).not.toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onStop).not.toHaveBeenCalled();
    expect(onSend).toHaveBeenCalledWith("one more thing:", undefined, {
      continueActiveTurn: true,
    });
  });

  it("interjects with the send button on coarse-pointer devices while streaming", () => {
    stubCoarsePointer();
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "hold on, actually…" } });
    const keyEvent = createEvent.keyDown(input, { key: "Enter" });
    fireEvent(input, keyEvent);

    expect(keyEvent.defaultPrevented).toBe(false);
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("button", { name: "Send message" })).toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("hold on, actually…", undefined, {
      continueActiveTurn: true,
    });
  });

  it("includes waiting guidance when the send button submits a newer draft", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} onStop={vi.fn()} isStreaming />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "waiting guidance" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.change(input, { target: { value: "send this now" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("waiting guidance\nsend this now", undefined, { continueActiveTurn: true });
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it("does not mark side-channel commands as guidance during an active turn", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} onStop={vi.fn()} isStreaming slashCommands={COMMANDS} />);
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "/history 5" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));

    expect(onSend).toHaveBeenCalledWith("/history 5", undefined, { sideChannel: true });
  });

  it("keeps Stop available while a draft attachment is encoding", () => {
    vi.mocked(encodeImage).mockReturnValueOnce(new Promise(() => {}));
    const onStop = vi.fn();
    const { container } = render(<ThreadComposer onSend={vi.fn()} onStop={onStop} isStreaming />);
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "unfinished draft" } });
    fireEvent.change(container.querySelector('input[type="file"]')!, {
      target: { files: [new File(["image"], "photo.png", { type: "image/png" })] },
    });
    fireEvent.click(screen.getByRole("button", { name: "Stop response" }));
    expect(onStop).toHaveBeenCalledOnce();
    expect(screen.getByLabelText("Message input")).toHaveValue("unfinished draft");
  });

  it("queues plain guidance while a task is running", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    expect(input).toHaveAttribute("placeholder", "Type your message...");
    fireEvent.change(input, { target: { value: "keep the UI minimal" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).not.toHaveBeenCalled();
    expect(input).toHaveValue("");
    expect(screen.getByText("keep the UI minimal")).toBeInTheDocument();
    expect(screen.getByText("Waiting to send")).toBeInTheDocument();
    expect(screen.queryByText(
      "Send now, or wait for the current response to finish.",
    )).not.toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Send now" }));

    expect(onSend).toHaveBeenCalledWith(
      "keep the UI minimal",
      undefined,
      { continueActiveTurn: true },
    );
    expect(screen.queryByText("keep the UI minimal")).not.toBeInTheDocument();
  });

  it.each(["/tmp", "/home/user/project", "/stop/config.json", "/neaw"])(
    "queues ordinary slash-prefixed text %s until the response finishes",
    (content) => {
      const onSend = vi.fn();
      const composer = (isStreaming: boolean) => (
        <ThreadComposer onSend={onSend} isStreaming={isStreaming} slashCommands={COMMANDS} />
      );
      const { rerender } = render(composer(true));
      const input = screen.getByLabelText("Message input");
      fireEvent.change(input, { target: { value: content } });
      expect(screen.queryByTestId("composer-slash-command")).not.toBeInTheDocument();
      fireEvent.keyDown(input, { key: "Enter" });

      expect(onSend).not.toHaveBeenCalled();
      expect(screen.getByRole("group", { name: "Waiting to send" })).toHaveTextContent(content);

      rerender(composer(false));

      expect(onSend).toHaveBeenCalledTimes(1);
      expect(onSend).toHaveBeenCalledWith(content);
      expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    },
  );

  it.each(["/history 5", "/stop now", "/STOP@nanobot now"])(
    "sends registered command %s to the gateway without queuing it",
    (content) => {
      const onSend = vi.fn();
      render(<ThreadComposer onSend={onSend} isStreaming slashCommands={COMMANDS} />);
      fireEvent.change(screen.getByLabelText("Message input"), { target: { value: content } });
      fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });

      expect(onSend).toHaveBeenCalledTimes(1);
      expect(onSend.mock.calls[0][0]).toBe(content);
      expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    },
  );

  it("guides queued guidance when Enter is pressed again", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "send this guidance now" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).not.toHaveBeenCalled();
    expect(input).toHaveValue("");
    expect(screen.getByText("send this guidance now")).toBeInTheDocument();

    fireEvent.keyDown(input, { key: "Enter", repeat: true });

    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByText("send this guidance now")).toBeInTheDocument();

    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledWith(
      "send this guidance now",
      undefined,
      { continueActiveTurn: true },
    );
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByText("send this guidance now")).not.toBeInTheDocument();
  });

  it("does not send waiting guidance during keyboard recording or transcription", async () => {
    mockVoiceRecorder();
    const onSend = vi.fn();
    let finishTranscription!: (text: string) => void;
    const onTranscribeAudio = vi.fn(() => new Promise<string>((resolve) => { finishTranscription = resolve; }));
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        onTranscribeAudio={onTranscribeAudio}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "keep this queued" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.keyDown(window, { code: "KeyD", ctrlKey: true, key: "D", shiftKey: true });

    expect(await screen.findByLabelText("Recording 0:00")).toBeInTheDocument();
    expect(input).toHaveFocus();
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByText("keep this queued")).toBeInTheDocument();

    await waitForVoiceCapture();
    fireEvent.keyUp(window, { code: "KeyD", ctrlKey: true, key: "D", shiftKey: true });
    await waitFor(() => expect(onTranscribeAudio).toHaveBeenCalled());
    fireEvent.keyDown(input, { key: "Enter" });
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("group", { name: "Waiting to send" })).toHaveTextContent("keep this queued");
    await act(async () => { finishTranscription("voice guidance"); });
    expect(input).toHaveValue("voice guidance");
  });

  it("keeps stopped guidance paused until an explicit Enter", () => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    const { rerender } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "keep this queued" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.click(screen.getByRole("button", { name: "Stop response" }));

    expect(onStop).toHaveBeenCalledTimes(1);
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByText("keep this queued")).toBeInTheDocument();

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={onStop}
        isStreaming={false}
        placeholder="Type your message..."
      />,
    );
    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={onStop}
        isStreaming
        placeholder="Type your message..."
      />,
    );
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByText("keep this queued")).toBeInTheDocument();
    fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });

    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith(
      "keep this queued", undefined, { continueActiveTurn: true },
    );
  });

  it.each(["refocusing", "clearing edits"])("sends waiting guidance with Enter after %s", (interaction) => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "leave this queued" } });
    fireEvent.keyDown(input, { key: "Enter" });
    if (interaction === "refocusing") {
      fireEvent.blur(input);
      fireEvent.focus(input);
    } else {
      fireEvent.change(input, { target: { value: "x" } });
      fireEvent.change(input, { target: { value: "" } });
    }
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith(
      "leave this queued", undefined, { continueActiveTurn: true },
    );
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it.each(["shiftKey", "altKey", "ctrlKey", "metaKey"])("keeps waiting guidance on modified Enter (%s)", (modifier) => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} isStreaming />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "waiting guidance" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.keyDown(input, { key: "Enter", [modifier]: true });
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("group", { name: "Waiting to send" })).toHaveTextContent("waiting guidance");

    fireEvent.keyDown(input, { key: "Enter" });
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith("waiting guidance", undefined, { continueActiveTurn: true });
  });

  it("keeps waiting guidance during IME confirmation and sends after composition ends", () => {
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} isStreaming />);
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "waiting guidance" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.compositionStart(input);
    fireEvent.keyDown(input, { key: "Enter", isComposing: true });
    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("group", { name: "Waiting to send" })).toHaveTextContent("waiting guidance");

    fireEvent.compositionEnd(input, { data: "" });
    fireEvent.keyDown(input, { key: "Enter" });
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith(
      "waiting guidance", undefined, { continueActiveTurn: true },
    );
  });

  it("merges consecutive queued inputs and interjects the whole message on a second Enter", () => {
    const onSend = vi.fn();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "older guidance" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.change(input, { target: { value: "guide this one now" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).toHaveBeenCalledWith(
      "older guidance\nguide this one now",
      undefined,
      { continueActiveTurn: true },
    );
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it("shows one pending message and sends all consecutive inputs once after completion", async () => {
    const onSend = vi.fn();
    const { rerender } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "first follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.change(input, { target: { value: "second follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });

    const queue = screen.getByRole("group", { name: "Waiting to send" });
    expect(queue).toHaveClass("composer-status-strip");
    expect(queue).toHaveClass("mx-3");
    expect(queue.parentElement?.className).toContain("group/composer");
    expect(within(queue).getByText("first follow-up second follow-up")).toHaveTextContent("first follow-up second follow-up");
    expect(within(queue).getAllByRole("button", { name: "Edit message" })).toHaveLength(1);
    expect(within(queue).getAllByRole("button", { name: "Send now" })).toHaveLength(1);

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming={false}
        placeholder="Type your message..."
      />,
    );

    await waitFor(() => {
      expect(onSend).toHaveBeenCalledWith("first follow-up\nsecond follow-up");
    });
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );
    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming={false}
        placeholder="Type your message..."
      />,
    );

    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it("lets users edit queued guidance before it is sent", async () => {
    const onSend = vi.fn();
    const { rerender } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "rough follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });

    const editButton = screen.getByRole("button", { name: "Edit message" });
    const textarea = input as HTMLTextAreaElement;
    const setSelection = textarea.setSelectionRange.bind(textarea);
    const focusedSelections: boolean[] = [];
    vi.spyOn(textarea, "setSelectionRange").mockImplementation((start, end, direction) => {
      focusedSelections.push(document.activeElement === textarea);
      setSelection(start, end, direction);
    });
    await userEvent.click(editButton);
    await waitFor(() => {
      expect(input).toHaveFocus();
    });
    expect(focusedSelections).toEqual([true]);
    expect(textarea.selectionStart).toBe("rough follow-up".length);
    expect(input).toHaveValue("rough follow-up");
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    fireEvent.change(input, { target: { value: "polished follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming={false}
        placeholder="Type your message..."
      />,
    );

    await waitFor(() => {
      expect(onSend).toHaveBeenCalledWith("polished follow-up");
    });
  });

  it("edits the complete pending message without overwriting a newer draft", () => {
    const onSend = vi.fn();
    const { rerender } = render(<ThreadComposer onSend={onSend} isStreaming />);
    const input = screen.getByLabelText("Message input");
    for (const text of ["first follow-up", "second follow-up"]) {
      fireEvent.change(input, { target: { value: text } });
      fireEvent.keyDown(input, { key: "Enter" });
    }
    fireEvent.change(input, { target: { value: "third follow-up" } });
    fireEvent.click(screen.getByRole("button", { name: "Edit message" }));
    expect(input).toHaveValue("first follow-up\nsecond follow-up\nthird follow-up");
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    fireEvent.change(input, { target: { value: "edited complete message" } });
    fireEvent.keyDown(input, { key: "Enter" });
    rerender(<ThreadComposer onSend={onSend} />);
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith("edited complete message");
  });

  it("queues image guidance while running and restores it for editing", async () => {
    mockBlobUrls();
    const onSend = vi.fn();
    const { container, rerender } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    const fileInput = container.querySelector<HTMLInputElement>('input[type="file"]');
    expect(fileInput).toBeTruthy();
    const file = new File(["image"], "draft.png", { type: "image/png" });
    fireEvent.change(fileInput!, { target: { files: [file] } });
    await screen.findByRole("img", { name: "draft.png" });

    fireEvent.change(input, { target: { value: "look at this" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(onSend).not.toHaveBeenCalled();
    expect(screen.getByRole("group", { name: "Waiting to send" })).toBeInTheDocument();
    expect(screen.getByText("look at this")).toBeInTheDocument();
    expect(screen.queryByTestId("composer-chip")).not.toBeInTheDocument();

    fireEvent.click(screen.getByRole("button", { name: "Edit message" }));
    expect(input).toHaveValue("look at this");
    expect(screen.getByRole("img", { name: "draft.png" })).toBeInTheDocument();
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();

    fireEvent.keyDown(input, { key: "Enter" });
    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming={false}
        placeholder="Type your message..."
      />,
    );

    await waitFor(() => {
      expect(onSend).toHaveBeenCalledWith(
        "look at this",
        [expect.objectContaining({
          media: expect.objectContaining({
            data_url: "data:image/png;base64,aW1hZ2U=",
            name: "draft.png",
          }),
        })],
      );
    });
  });

  it("deletes the complete pending message across remounts", () => {
    const onSend = vi.fn();
    const first = render(<ThreadComposer onSend={onSend} isStreaming pendingQueueKey="chat-a" />);
    const input = screen.getByLabelText("Message input");
    for (const text of ["1", "2"]) {
      fireEvent.change(input, { target: { value: text } });
      fireEvent.keyDown(input, { key: "Enter" });
    }
    fireEvent.click(screen.getByRole("button", { name: "Delete message" }));
    first.unmount();
    render(<ThreadComposer onSend={onSend} pendingQueueKey="chat-a" />);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
  });

  it("keeps queued guidance in its session when switching from running to idle", () => {
    const sendA = vi.fn();
    const sendB = vi.fn();
    const view = render(
      <ThreadComposer onSend={sendA} isStreaming pendingQueueKey="chat-a" />,
    );
    fireEvent.change(screen.getByLabelText("Message input"), {
      target: { value: "follow-up for A" },
    });
    fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });
    expect(screen.getByText("follow-up for A")).toBeInTheDocument();
    expect(sendA).not.toHaveBeenCalled();

    view.rerender(
      <ThreadComposer onSend={sendB} isStreaming={false} pendingQueueKey="chat-b" />,
    );
    expect(sendB).not.toHaveBeenCalled();
    expect(screen.queryByText("follow-up for A")).not.toBeInTheDocument();

    view.rerender(
      <ThreadComposer onSend={sendA} isStreaming pendingQueueKey="chat-a" />,
    );
    expect(screen.getByText("follow-up for A")).toBeInTheDocument();
    expect(sendA).not.toHaveBeenCalled();
    view.rerender(
      <ThreadComposer onSend={sendA} isStreaming={false} pendingQueueKey="chat-a" />,
    );
    expect(sendA).toHaveBeenCalledTimes(1);
    expect(sendA).toHaveBeenCalledWith("follow-up for A");
    expect(sendB).not.toHaveBeenCalled();
    expect(screen.queryByText("follow-up for A")).not.toBeInTheDocument();
  });

  it("persists queued guidance per chat across remounts", async () => {
    const onSend = vi.fn();
    const { rerender, unmount } = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey="chat-a"
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "remember this follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });
    fireEvent.click(screen.getByRole("button", { name: "Edit message" }));
    fireEvent.change(input, { target: { value: "remember this edited follow-up" } });
    fireEvent.keyDown(input, { key: "Enter" });
    expect(screen.getByText("remember this edited follow-up")).toBeInTheDocument();

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey="chat-b"
        placeholder="Type your message..."
      />,
    );
    await waitFor(() => {
      expect(screen.queryByText("remember this edited follow-up")).not.toBeInTheDocument();
    });

    rerender(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey="chat-a"
        placeholder="Type your message..."
      />,
    );
    expect(await screen.findByText("remember this edited follow-up")).toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();

    unmount();
    const remount = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey="chat-a"
        placeholder="Type your message..."
      />,
    );

    expect(await screen.findByText("remember this edited follow-up")).toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith(
      "remember this edited follow-up",
      undefined,
      { continueActiveTurn: true },
    );

    remount.unmount();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey="chat-a"
        placeholder="Type your message..."
      />,
    );
    await waitFor(() => {
      expect(screen.queryByText("remember this edited follow-up")).not.toBeInTheDocument();
    });
  });

  it("resumes a restored queue only after its waiting turn is confirmed complete", async () => {
    let acceptDelivery!: (accepted: boolean) => void;
    const delivery = new Promise<boolean>((resolve) => { acceptDelivery = resolve; });
    const onSend = vi.fn().mockReturnValueOnce(delivery);
    const first = render(
      <ThreadComposer onSend={onSend} isStreaming activeTurnId="turn-a" pendingQueueKey="chat-a" />,
    );
    const input = screen.getByLabelText("Message input");
    for (const text of ["first follow-up", "second follow-up"]) {
      fireEvent.change(input, { target: { value: text } });
      fireEvent.keyDown(input, { key: "Enter" });
    }
    first.unmount();
    const otherSend = vi.fn();
    const other = render(
      <ThreadComposer onSend={otherSend} pendingQueueKey="chat-b" completedTurnIds={["turn-a"]} />,
    );
    expect(otherSend).not.toHaveBeenCalled();
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    other.unmount();

    const returned = render(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={[]} />,
    );
    expect(screen.getByText("first follow-up second follow-up")).toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-other"]} />,
    );
    expect(onSend).not.toHaveBeenCalled();
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
    );
    await waitFor(() => expect(onSend).toHaveBeenCalledWith("first follow-up\nsecond follow-up"));
    for (let update = 0; update < 3; update += 1) {
      returned.rerender(
        <ThreadComposer onSend={(...args) => onSend(...args)} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
      );
    }
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.getByRole("button", { name: "Send now" })).toBeDisabled();
    await act(async () => { acceptDelivery(true); await delivery; });
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" isStreaming activeTurnId="turn-next" completedTurnIds={["turn-a"]} />,
    );
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
    );
    expect(onSend).toHaveBeenCalledTimes(1);
    returned.unmount();
    render(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a", "turn-next"]} />,
    );
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("group", { name: "Waiting to send" })).not.toBeInTheDocument();
  });

  it.each(["button", "palette"])("keeps queued messages manual after stopping through %s and remounting", (entrypoint) => {
    const onSend = vi.fn();
    const onStop = vi.fn();
    const view = render(
      <ThreadComposer onSend={onSend} onStop={onStop} isStreaming activeTurnId="turn-a" pendingQueueKey="chat-a" slashCommands={COMMANDS} />,
    );
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "keep for later" } });
    fireEvent.keyDown(input, { key: "Enter" });
    if (entrypoint === "button") fireEvent.click(screen.getByRole("button", { name: "Stop response" }));
    else {
      fireEvent.change(input, { target: { value: "/sto" } });
      fireEvent.mouseDown(screen.getByRole("option", { name: /\/stop/i }));
    }
    expect(onStop).toHaveBeenCalledTimes(1);
    view.unmount();
    const returned = render(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
    );
    expect(screen.getByText("keep for later")).toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
    // A run started in another pane must not re-arm a queue the user stopped.
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" isStreaming activeTurnId="turn-other-pane" completedTurnIds={["turn-a"]} />,
    );
    returned.rerender(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a", "turn-other-pane"]} />,
    );
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.click(screen.getByRole("button", { name: "Send now" }));
    expect(onSend).toHaveBeenCalledTimes(1);
    expect(onSend).toHaveBeenCalledWith("keep for later");
  });

  it("retains a rejected queued attachment for manual retry after remounting", async () => {
    mockBlobUrls();
    let rejectDelivery!: (error: Error) => void;
    const delivery = new Promise<boolean>((_resolve, reject) => { rejectDelivery = reject; });
    const onSend = vi.fn().mockReturnValue(delivery);
    const first = render(
      <ThreadComposer onSend={onSend} isStreaming activeTurnId="turn-a" pendingQueueKey="chat-a" />,
    );
    fireEvent.change(first.container.querySelector<HTMLInputElement>('input[type="file"]')!, {
      target: { files: [new File(["image"], "queued.png", { type: "image/png" })] },
    });
    await screen.findByRole("img", { name: "queued.png" });
    for (const text of ["queued attachment", "more guidance"]) {
      fireEvent.change(screen.getByLabelText("Message input"), { target: { value: text } });
      fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "Enter" });
    }
    first.unmount();
    const returned = render(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
    );
    await waitFor(() => expect(onSend).toHaveBeenCalledTimes(1));
    await act(async () => { rejectDelivery(new Error("Attachment upload interrupted")); });
    expect(screen.getByText("queued attachment more guidance")).toBeInTheDocument();
    expect(onSend).toHaveBeenCalledTimes(1);
    returned.unmount();
    render(
      <ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["turn-a"]} />,
    );
    expect(screen.getByText("queued attachment more guidance")).toBeInTheDocument();
    expect(onSend).toHaveBeenCalledTimes(1);
    onSend.mockReturnValue(true);
    fireEvent.click(screen.getByRole("button", { name: "Send now" }));
    expect(onSend).toHaveBeenCalledTimes(2);
    expect(onSend.mock.calls[1][0]).toBe("queued attachment\nmore guidance");
    expect(onSend.mock.calls[1][1]).toEqual([expect.objectContaining({ media: expect.objectContaining({ name: "queued.png" }) })]);
  });

  it("retains legacy queued drafts for manual sending when mounted idle", () => {
    window.localStorage.setItem("nanobot.webui.composerQueuedGuidance.v1:chat-a", JSON.stringify([
      { id: "legacy-draft", text: "legacy follow-up" },
    ]));
    const onSend = vi.fn();
    render(<ThreadComposer onSend={onSend} pendingQueueKey="chat-a" completedTurnIds={["old-turn"]} />);
    expect(screen.getByText("legacy follow-up")).toBeInTheDocument();
    expect(onSend).not.toHaveBeenCalled();
    fireEvent.click(screen.getByRole("button", { name: "Send now" }));
    expect(onSend).toHaveBeenCalledWith("legacy follow-up");
  });

  it("keeps temporary chat guidance in memory only", async () => {
    const setItem = vi.spyOn(window.localStorage, "setItem");
    const onSend = vi.fn();
    const view = render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey={null}
        placeholder="Type your message..."
      />,
    );

    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "do not persist this" } });
    fireEvent.keyDown(input, { key: "Enter" });

    expect(await screen.findByText("do not persist this")).toBeInTheDocument();
    expect(setItem).not.toHaveBeenCalled();

    view.unmount();
    render(
      <ThreadComposer
        onSend={onSend}
        onStop={vi.fn()}
        isStreaming
        pendingQueueKey={null}
        placeholder="Type your message..."
      />,
    );

    await waitFor(() => {
      expect(screen.queryByText("do not persist this")).not.toBeInTheDocument();
    });
    expect(setItem).not.toHaveBeenCalled();
  });

});


describe("session composer drafts", () => {
  it("resolves typed draft handles when the catalog arrives and persists their identity", () => {
    const draftStore = new ComposerDraftStore();
    const onSend = vi.fn();
    const target = session("pricing", "Pricing", "", "bime");
    const composer = (sessions: ChatSummary[], store = draftStore) => (
      <ThreadComposer draftKey="typed-handle" draftStore={store} persistDraft onSend={onSend} sessions={sessions} />
    );
    const view = render(composer([]));
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "参考 @bime" } });
    expect(screen.queryByTestId("composer-session-mention-bime")).not.toBeInTheDocument();

    view.rerender(composer([target]));
    expect(screen.getByTestId("composer-session-mention-bime")).toBeInTheDocument();
    view.unmount();
    render(composer([], new ComposerDraftStore()));

    expect(screen.getByLabelText("Message input")).toHaveValue("参考 @bime");
    expect(screen.getByTestId("composer-session-mention-bime")).toBeInTheDocument();
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("参考 @bime", undefined, {
      sessionMentions: [{ id: target.handle?.id, name: "bime", session_key: target.key, title: "Pricing" }],
    });
  });

  it("restores independent drafts across session switches and remounts", () => {
    const draftStore = new ComposerDraftStore();
    const composer = (key: string) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} onSend={vi.fn()} />
    );
    const view = render(composer("chat-a"));
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "  draft A\nnext line" } });
    view.rerender(composer("chat-b"));
    expect(screen.getByLabelText("Message input")).toHaveValue("");
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "draft B" } });
    view.rerender(composer("chat-a"));
    expect(screen.getByLabelText("Message input")).toHaveValue("  draft A\nnext line");
    fireEvent.keyDown(screen.getByLabelText("Message input"), { key: "z", ctrlKey: true });
    expect(screen.getByLabelText("Message input")).toHaveValue("  draft A\nnext line");
    view.unmount();
    render(composer("chat-b"));
    expect(screen.getByLabelText("Message input")).toHaveValue("draft B");
  });

  it("retains in-progress IME text without carrying composition into another chat", () => {
    const draftStore = new ComposerDraftStore();
    const composer = (key: string) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} onSend={vi.fn()} cliApps={CLI_APPS} />
    );
    const view = render(composer("chat-a"));
    const input = screen.getByLabelText("Message input");
    fireEvent.change(input, { target: { value: "@gimp " } });
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: "@\u00a0GIMP 草稿" } });
    view.rerender(composer("chat-b"));
    expect(screen.getByLabelText("Message input")).toHaveValue("");
    view.rerender(composer("chat-a"));
    expect(screen.getByLabelText("Message input")).toHaveValue("@\u00a0GIMP 草稿");
  });

  it.each([true, false])("clears only accepted sends (accepted=%s)", (accepted) => {
    const draftStore = new ComposerDraftStore();
    const composer = (key: string) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} onSend={() => accepted} />
    );
    const view = render(composer("chat-a"));
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "send me" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    view.rerender(composer("chat-b"));
    view.rerender(composer("chat-a"));
    expect(screen.getByLabelText("Message input")).toHaveValue(accepted ? "" : "send me");
  });

  it.each([false, true])("clears an accepted draft after restoring it unchanged (attachment=%s)", async (attachment) => {
    mockBlobUrls();
    const draftStore = new ComposerDraftStore();
    let resolveSend!: (accepted: boolean) => void;
    const onSend = vi.fn(() => new Promise<boolean>((resolve) => { resolveSend = resolve; }));
    const composer = (key: string) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} persistDraft onSend={onSend} />
    );
    const view = render(composer("unchanged-draft"));
    fireEvent.change(screen.getByRole("textbox"), { target: { value: "send once" } });
    if (attachment) {
      const file = new File(["image"], "draft.png", { type: "image/png" });
      fireEvent.change(view.container.querySelector('input[type="file"]')!, { target: { files: [file] } });
      await waitFor(() => expect(screen.getByRole("button", { name: "Send message" })).toBeEnabled());
    }
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    view.rerender(composer("other-draft"));
    view.rerender(composer("unchanged-draft"));
    expect(screen.getByRole("textbox")).toHaveValue("send once");
    if (attachment) await screen.findByRole("img", { name: "draft.png" });
    fireEvent.click(screen.getByRole("textbox"));
    await act(async () => resolveSend(true));
    view.unmount();
    expect(new ComposerDraftStore().get("unchanged-draft", true)).toBeUndefined();
  });

  it("does not delete a newer draft when an earlier async send completes", async () => {
    const draftStore = new ComposerDraftStore();
    let resolveSend!: (accepted: boolean) => void;
    const onSend = vi.fn(() => new Promise<boolean>((resolve) => { resolveSend = resolve; }));
    const composer = (key: string) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} onSend={onSend} />
    );
    const view = render(composer("chat-a"));
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "first" } });
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    view.rerender(composer("chat-b"));
    view.rerender(composer("chat-a"));
    fireEvent.change(screen.getByLabelText("Message input"), { target: { value: "newer draft" } });
    await act(async () => resolveSend(true));
    view.rerender(composer("chat-b"));
    view.rerender(composer("chat-a"));
    expect(screen.getByLabelText("Message input")).toHaveValue("newer draft");
  });

  it("restores attachments and quoted context with their original session", async () => {
    mockBlobUrls();
    const draftStore = new ComposerDraftStore();
    const onSend = vi.fn();
    const composer = (key: string, quote = draftStore.get(key)?.quotedContext) => (
      <ThreadComposer key={key} draftKey={key} draftStore={draftStore} quotedContext={quote} onSend={onSend} />
    );
    const view = render(composer("chat-a", "quoted answer"));
    const file = new File(["image"], "draft.png", { type: "image/png" });
    fireEvent.change(view.container.querySelector('input[type="file"]')!, { target: { files: [file] } });
    view.rerender(composer("chat-b"));
    expect(screen.queryByRole("img", { name: "draft.png" })).not.toBeInTheDocument();
    expect(screen.queryByLabelText("Quoted context")).not.toBeInTheDocument();
    view.rerender(composer("chat-a"));
    expect(await screen.findByRole("img", { name: "draft.png" })).toBeInTheDocument();
    expect(screen.getByLabelText("Quoted context")).toHaveTextContent("quoted answer");
    await waitFor(() => expect(screen.getByRole("button", { name: "Send message" })).toBeEnabled());
    fireEvent.click(screen.getByRole("button", { name: "Send message" }));
    expect(onSend).toHaveBeenCalledWith("", [expect.objectContaining({
      media: expect.objectContaining({ name: "draft.png" }),
    })], { quotedContext: "quoted answer" });
  });
});