@tribe-nest/forge 3.60.0 → 3.63.0

package/src/ui/styled/community/_tests/CommunityAgent.spec.tsx

@@ -0,0 +1,571 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import type { ReactNode } from "react";
+
+import {
+  COMMUNITY,
+  PROFILE_ID,
+  account,
+  calls,
+  get,
+  installAdapter,
+  meRoute,
+  post,
+  restoreAdapter,
+  viewer,
+  wrapper,
+  type Route,
+} from "../../../headless/_tests/communityHarness";
+import type { CommunityPost, CommunityReply } from "../../../../data/queries/useCommunity";
+import type { ChatMessage } from "../../../../data/queries/useChat";
+import { CommunityPostCard } from "../CommunityPostCard";
+import { CommunityPostDetail } from "../CommunityPostDetail";
+import { ChatRoom } from "../../ChatRoom";
+import { MessageBubble } from "../../chat/MessageBubble";
+import { ChatThreadPanel } from "../../chat/ChatThreadPanel";
+
+/**
+ * The community AI as a member sees it, rendered for real over the harness's
+ * stub adapter, with a fake socket standing in for the realtime gateway so the
+ * thinking and held-content events can be delivered by hand.
+ */
+
+const socketState = vi.hoisted(() => {
+  const listeners = new Set<(envelope: unknown) => void>();
+  return {
+    listeners,
+    socket: {
+      connected: true,
+      on: (event: string, fn: (envelope: unknown) => void) => {
+        if (event === "message") listeners.add(fn);
+      },
+      off: (event: string, fn: (envelope: unknown) => void) => {
+        if (event === "message") listeners.delete(fn);
+      },
+      emit: () => {},
+    },
+  };
+});
+
+vi.mock("socket.io-client", () => ({ io: () => socketState.socket }));
+
+const deliver = (event: string, data: unknown) =>
+  act(() => {
+    socketState.listeners.forEach((fn) => fn({ event, data }));
+  });
+
+const ME = account();
+const AGENT = { enabled: true, id: "agent-1", name: "Assistant", avatarUrl: null, dmEnabled: true };
+const AGENT_AUTHOR = { id: "agent-1", name: "Assistant", avatarUrl: null };
+const SOURCE_URL = "https://fans.example.com/c/fan-club/wiki/refunds";
+
+const lexical = (text: string) => ({
+  root: { type: "root", children: [{ type: "paragraph", children: [{ type: "text", text }] }] },
+});
+
+const memberAuthor = (accountId: string, name: string) => ({
+  accountId,
+  firstName: name,
+  lastName: null,
+  displayName: name,
+  avatarUrl: null,
+  level: 1,
+  role: "member",
+});
+
+const basePost = (overrides: Partial<CommunityPost> = {}): CommunityPost => ({
+  id: "post-1",
+  profileId: PROFILE_ID,
+  spaceId: "space-1",
+  authorAccountId: "someone",
+  title: "Tour dates",
+  body: lexical("Where next?"),
+  bodyText: "Where next?",
+  isPinned: false,
+  isLocked: false,
+  replyCount: 2,
+  reactionCount: 0,
+  lastActivityAt: null,
+  createdAt: "2026-09-30T10:00:00.000Z",
+  author: memberAuthor("someone", "Sam"),
+  agentAuthor: null,
+  media: [],
+  reactions: [],
+  status: "published",
+  ...overrides,
+});
+
+const memberReply = (id: string, authorAccountId: string, name: string, parentReplyId: string | null = null): CommunityReply => ({
+  id,
+  postId: "post-1",
+  parentReplyId,
+  authorAccountId,
+  body: lexical(`${name} says hi`),
+  bodyText: `${name} says hi`,
+  reactionCount: 0,
+  createdAt: "2026-09-30T10:05:00.000Z",
+  author: memberAuthor(authorAccountId, name),
+  agentAuthor: null,
+  media: [],
+  reactions: [],
+  status: "published",
+});
+
+const agentReply = (id: string, parentReplyId: string | null): CommunityReply => ({
+  id,
+  postId: "post-1",
+  parentReplyId,
+  authorAccountId: null,
+  body: lexical(`Refunds take five days.\n\nSources:\n- [Refunds](${SOURCE_URL})`),
+  bodyText: "Refunds take five days.",
+  reactionCount: 0,
+  createdAt: "2026-09-30T10:06:00.000Z",
+  author: null,
+  agentAuthor: AGENT_AUTHOR,
+  media: [],
+  reactions: [],
+  status: "published",
+});
+
+const memberRoutes = (info: unknown = AGENT): Route[] => [
+  meRoute(() => viewer({ state: "member" })),
+  get("/public/community-agent", () => info),
+];
+
+const threadRoutes = (thePost: CommunityPost, replies: CommunityReply[]): Route[] => [
+  get("/public/community/posts/post-1", () => ({ post: thePost })),
+  get("/public/community/posts/post-1/replies", () => ({
+    data: replies,
+    total: replies.length,
+    page: 1,
+    pageSize: 100,
+    hasNextPage: false,
+  })),
+];
+
+function renderIn(ui: ReactNode, opts: { user?: unknown } = { user: ME }) {
+  const Wrapper = wrapper(opts);
+  return render(<Wrapper>{ui}</Wrapper>);
+}
+
+beforeEach(() => socketState.listeners.clear());
+afterEach(() => {
+  cleanup();
+  restoreAdapter();
+});
+
+describe("agent authorship", () => {
+  it("a post card shows the agent's name, glyph and AI badge, never the Member fallback", () => {
+    installAdapter([]);
+    renderIn(
+      <CommunityPostCard
+        post={basePost({ authorAccountId: null, author: null, agentAuthor: AGENT_AUTHOR })}
+        variant="feed"
+      />,
+    );
+    expect(screen.getByText("Assistant")).toBeTruthy();
+    expect(screen.getByTestId("community-agent-badge").textContent).toBe("AI");
+    expect(screen.getByTestId("community-agent-glyph")).toBeTruthy();
+    expect(screen.queryByText("Member")).toBeNull();
+  });
+
+  it("the forum row names the agent with its badge", () => {
+    installAdapter([]);
+    renderIn(
+      <CommunityPostCard post={basePost({ authorAccountId: null, author: null, agentAuthor: AGENT_AUTHOR })} variant="forum" />,
+    );
+    expect(screen.getByTestId("community-agent-badge")).toBeTruthy();
+    expect(screen.queryByText("Member")).toBeNull();
+  });
+
+  it("an agent avatar renders as the image when the creator set one", () => {
+    installAdapter([]);
+    renderIn(
+      <CommunityPostCard
+        post={basePost({ authorAccountId: null, author: null, agentAuthor: { ...AGENT_AUTHOR, avatarUrl: "https://cdn.test/a.png" } })}
+        variant="feed"
+      />,
+    );
+    expect((screen.getByAltText("Assistant") as HTMLImageElement).src).toBe("https://cdn.test/a.png");
+  });
+
+  it("a post card shows the thinking line only while asked to", () => {
+    installAdapter([]);
+    const { rerender } = renderIn(<CommunityPostCard post={basePost()} variant="feed" agentThinking={{ name: "Assistant" }} />);
+    expect(screen.getByTestId("community-agent-thinking").textContent).toContain("Assistant is thinking");
+    const Wrapper = wrapper({ user: ME });
+    rerender(
+      <Wrapper>
+        <CommunityPostCard post={basePost()} variant="feed" agentThinking={null} />
+      </Wrapper>,
+    );
+    expect(screen.queryByTestId("community-agent-thinking")).toBeNull();
+  });
+
+  it("an agent reply in a thread: badge, clickable sources, no member fallback", async () => {
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan"), agentReply("ai-1", "r1")])]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    const reply = await screen.findByTestId("community-agent-reply");
+    expect(within(reply).getByText("Assistant")).toBeTruthy();
+    expect(within(reply).getByTestId("community-agent-badge")).toBeTruthy();
+    expect(within(reply).queryByText("Member")).toBeNull();
+    // The "Sources:" line stays as text; each source reads as its title and
+    // links to its page in a new tab, with no raw address on screen.
+    expect(reply.textContent).toContain("Sources:");
+    expect(reply.textContent).not.toContain(SOURCE_URL);
+    const link = within(reply).getByRole("link", { name: "Refunds" }) as HTMLAnchorElement;
+    expect(link.href).toBe(SOURCE_URL);
+    expect(link.target).toBe("_blank");
+    expect(link.rel).toBe("noopener noreferrer");
+  });
+});
+
+/** The member's own ratings read: answers this account asked for, and nothing else. */
+const RATINGS_PATH = "/public/community-agent/feedback";
+const ratingsRoute = (rows: { entityId: string; feedback: 1 | -1 | null }[]): Route =>
+  get(RATINGS_PATH, (req) => {
+    const asked = String(req.params?.entityIds ?? "").split(",");
+    return { data: rows.filter((r) => asked.includes(r.entityId)) };
+  });
+
+describe("thumbs up / down in a thread", () => {
+  it("hydrates the saved rating on load and sends a new one", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan"), agentReply("ai-1", "r1"), agentReply("ai-2", "r1")]),
+      ratingsRoute([{ entityId: "ai-1", feedback: 1 }]),
+      post(RATINGS_PATH, () => ({ id: "ans", feedback: -1 })),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await waitFor(() => expect(screen.getAllByTestId("community-agent-feedback")).toHaveLength(1));
+    // One read for the thread, with every agent answer in it.
+    expect(calls("get", RATINGS_PATH)).toHaveLength(1);
+    expect(calls("get", RATINGS_PATH)[0].params).toEqual({
+      profileId: PROFILE_ID,
+      entityType: "community_reply",
+      entityIds: "ai-1,ai-2",
+    });
+    const feedback = screen.getByTestId("community-agent-feedback");
+    expect(within(feedback).getByRole("button", { name: "Helpful answer" }).getAttribute("aria-pressed")).toBe("true");
+    const down = within(feedback).getByRole("button", { name: "Not helpful" });
+    fireEvent.click(down);
+    expect(down.getAttribute("aria-pressed")).toBe("true");
+    await waitFor(() => expect(calls("post", RATINGS_PATH)).toHaveLength(1));
+    expect(calls("post", RATINGS_PATH)[0].body).toEqual({
+      profileId: PROFILE_ID,
+      entityType: "community_reply",
+      entityId: "ai-1",
+      value: -1,
+    });
+  });
+
+  it("offers thumbs only on answers the read returns, whoever wrote the parent", async () => {
+    // The parent is the viewer's own reply, but the read says they did not ask: no thumbs.
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan"), agentReply("ai-1", "r1")]),
+      ratingsRoute([]),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    const reply = await screen.findByTestId("community-agent-reply");
+    await waitFor(() => expect(calls("get", RATINGS_PATH)).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(within(reply).queryByTestId("community-agent-feedback")).toBeNull();
+  });
+
+  it("offers thumbs on an answer under someone else's reply when the read returns it", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost(), [memberReply("r1", "someone", "Sam"), agentReply("ai-1", "r1")]),
+      ratingsRoute([{ entityId: "ai-1", feedback: null }]),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    const reply = await screen.findByTestId("community-agent-reply");
+    await waitFor(() => expect(within(reply).getByTestId("community-agent-feedback")).toBeTruthy());
+  });
+
+  it("does not read ratings when the AI is off", async () => {
+    installAdapter([
+      ...memberRoutes({ enabled: false }),
+      ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan"), agentReply("ai-1", "r1")]),
+      ratingsRoute([{ entityId: "ai-1", feedback: 1 }]),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByTestId("community-agent-reply");
+    await waitFor(() => expect(calls("get", "/public/community-agent")).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(calls("get", RATINGS_PATH)).toHaveLength(0);
+    expect(screen.queryByTestId("community-agent-feedback")).toBeNull();
+  });
+});
+
+describe("thinking and held content in an open thread", () => {
+  it("shows the thinking line on thinking and drops it on done", async () => {
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan")])]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Fan says hi");
+    await waitFor(() => expect(socketState.listeners.size).toBeGreaterThan(0));
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "thinking" });
+    await waitFor(() => expect(screen.getByTestId("community-agent-thinking").textContent).toContain("Assistant is thinking"));
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "done" });
+    expect(screen.queryByTestId("community-agent-thinking")).toBeNull();
+  });
+
+  it("clears the thinking line when the answer arrives, and shows the answer", async () => {
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan")])]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Fan says hi");
+    await waitFor(() => expect(socketState.listeners.size).toBeGreaterThan(0));
+    deliver("communityAgentThinking", { postId: "post-1", agentId: "agent-1", state: "thinking" });
+    deliver("communityNewReply", { spaceId: "space-1", postId: "post-1", reply: agentReply("ai-9", "r1") });
+    expect(screen.queryByTestId("community-agent-thinking")).toBeNull();
+    expect(await screen.findByTestId("community-agent-reply")).toBeTruthy();
+  });
+
+  it("removes a reply that auto-moderation sent back to the queue", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost(), [memberReply("r1", ME.id, "Fan"), memberReply("r2", "someone", "Sam")]),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Sam says hi");
+    await waitFor(() => expect(socketState.listeners.size).toBeGreaterThan(0));
+    deliver("communityContentHeld", { spaceId: "space-1", entityType: "community_reply", postId: "post-1", replyId: "r2" });
+    await waitFor(() => expect(screen.queryByText("Sam says hi")).toBeNull());
+    expect(screen.getByText("Fan says hi")).toBeTruthy();
+  });
+
+  it("closes the open post for a reader when the post itself is held", async () => {
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost(), [])]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Tour dates");
+    await waitFor(() => expect(socketState.listeners.size).toBeGreaterThan(0));
+    deliver("communityContentHeld", { spaceId: "space-1", entityType: "community_post", postId: "post-1", replyId: null });
+    await waitFor(() => expect(screen.getByText("This post is unavailable.")).toBeTruthy());
+  });
+});
+
+describe("catch me up", () => {
+  const many = Array.from({ length: 10 }, (_, i) => memberReply(`r${i}`, "someone", `Member${i}`));
+  const summaryPath = "/public/community-agent/posts/post-1/summary";
+
+  it("is offered on a long thread when the AI is on, and not on a short one", async () => {
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost({ replyCount: 10 }), many)]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    expect(await screen.findByRole("button", { name: "Catch me up" })).toBeTruthy();
+    cleanup();
+    restoreAdapter();
+    installAdapter([...memberRoutes(), ...threadRoutes(basePost({ replyCount: 9 }), many.slice(0, 9))]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Member0 says hi");
+    await new Promise((r) => setTimeout(r, 20));
+    expect(screen.queryByRole("button", { name: "Catch me up" })).toBeNull();
+  });
+
+  it("is not offered when the AI is off", async () => {
+    installAdapter([...memberRoutes({ enabled: false }), ...threadRoutes(basePost({ replyCount: 10 }), many)]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    await screen.findByText("Member0 says hi");
+    await waitFor(() => expect(calls("get", "/public/community-agent")).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(screen.queryByRole("button", { name: "Catch me up" })).toBeNull();
+  });
+
+  it("shows the private summary, labelled as the AI's, and dismisses it", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost({ replyCount: 10 }), many),
+      post(summaryPath, () => ({ summary: "Everyone wants Berlin.", agentName: "Assistant" })),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    fireEvent.click(await screen.findByRole("button", { name: "Catch me up" }));
+    const panel = await screen.findByTestId("community-catch-me-up-panel");
+    expect(panel.textContent).toContain("Everyone wants Berlin.");
+    expect(within(panel).getByTestId("community-agent-badge")).toBeTruthy();
+    expect(panel.textContent).toContain("only you can see it");
+    expect(calls("post", summaryPath)[0].body).toEqual({ profileId: PROFILE_ID, communityId: COMMUNITY.id });
+    fireEvent.click(within(panel).getByRole("button", { name: "Dismiss summary" }));
+    expect(screen.queryByTestId("community-catch-me-up-panel")).toBeNull();
+  });
+
+  it.each([
+    [409, "reached today's limit"],
+    [400, "can't summarise this thread"],
+  ])("says so plainly on a %s", async (status, copy) => {
+    installAdapter([
+      ...memberRoutes(),
+      ...threadRoutes(basePost({ replyCount: 10 }), many),
+      post(summaryPath, () => {
+        throw { status };
+      }),
+    ]);
+    renderIn(<CommunityPostDetail postId="post-1" />);
+    fireEvent.click(await screen.findByRole("button", { name: "Catch me up" }));
+    const error = await screen.findByTestId("community-catch-me-up-error");
+    expect(error.textContent).toContain(copy);
+    expect(screen.queryByTestId("community-catch-me-up-panel")).toBeNull();
+  });
+});
+
+describe("chat", () => {
+  const agentMessage = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
+    id: "m-ai",
+    channelId: "chan-ai",
+    content: `Refunds take five days.\nSources:\n- [Refunds](${SOURCE_URL})`,
+    senderAccountId: null,
+    senderAgentId: "agent-1",
+    senderAgentAvatarUrl: null,
+    senderFirstName: "Assistant",
+    senderLastName: "",
+    isPinned: false,
+    attachments: [],
+    parentMessageId: null,
+    replyCount: 0,
+    lastReplyAt: null,
+    createdAt: "2026-09-30T10:00:00.000Z",
+    ...overrides,
+  });
+
+  it("an agent message shows its name and badge, a clickable source, and is never on my side", () => {
+    installAdapter([]);
+    renderIn(<MessageBubble message={agentMessage()} mine showThreadControls={false} />);
+    const bubble = screen.getByTestId("chat-agent-message");
+    expect(bubble.style.alignSelf).toBe("flex-start");
+    expect(within(bubble).getByText("Assistant")).toBeTruthy();
+    expect(within(bubble).getByTestId("community-agent-badge")).toBeTruthy();
+    expect(bubble.textContent).not.toContain(SOURCE_URL);
+    const link = within(bubble).getByRole("link", { name: "Refunds" }) as HTMLAnchorElement;
+    expect(link.target).toBe("_blank");
+    expect(link.rel).toBe("noopener noreferrer");
+  });
+
+  const channelsRoute = (channels: unknown[]): Route => get("/public/chat/channels", () => channels);
+  const messagesRoute = (messages: ChatMessage[]): Route =>
+    get(/^\/public\/chat\/channels\/[^/]+\/messages$/, () => ({ data: messages, total: messages.length, page: 1, limit: 50 }));
+
+  it("opens the agent DM from the chat sidebar and shows it with the agent's badge", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      channelsRoute([]),
+      messagesRoute([]),
+      get(/^\/public\/chat\/channels\/[^/]+\/pinned$/, () => []),
+      get("/public/chat/unread-counts", () => []),
+      get("/public/chat/dm/directory", () => []),
+      post("/public/community-agent/dm", () => ({ channelId: "chan-ai", agent: AGENT })),
+    ]);
+    renderIn(<ChatRoom />);
+    const open = await screen.findByTestId("chat-agent-dm-open");
+    expect(open.textContent).toContain("Message Assistant");
+    fireEvent.click(open);
+    await waitFor(() => expect(calls("post", "/public/community-agent/dm")).toHaveLength(1));
+    expect(calls("post", "/public/community-agent/dm")[0].body).toEqual({ profileId: PROFILE_ID, communityId: COMMUNITY.id });
+    // The DM's messages are read: the panel opened on the agent's channel.
+    await waitFor(() => expect(calls("get", "/public/chat/channels/chan-ai/messages")).toHaveLength(1));
+    const header = document.querySelector("header")!;
+    expect(within(header).getByText("Assistant")).toBeTruthy();
+    expect(within(header).getByTestId("community-agent-badge")).toBeTruthy();
+  });
+
+  it("says so when the DM cannot be opened", async () => {
+    installAdapter([
+      ...memberRoutes(),
+      channelsRoute([]),
+      get("/public/chat/unread-counts", () => []),
+      get("/public/chat/dm/directory", () => []),
+      post("/public/community-agent/dm", () => {
+        throw { status: 403 };
+      }),
+    ]);
+    renderIn(<ChatRoom />);
+    fireEvent.click(await screen.findByTestId("chat-agent-dm-open"));
+    expect((await screen.findByRole("alert")).textContent).toContain("couldn't open this conversation");
+  });
+
+  it("offers no DM entry when the creator switched agent DMs off", async () => {
+    installAdapter([
+      ...memberRoutes({ ...AGENT, dmEnabled: false }),
+      channelsRoute([]),
+      get("/public/chat/unread-counts", () => []),
+      get("/public/chat/dm/directory", () => []),
+    ]);
+    renderIn(<ChatRoom />);
+    await waitFor(() => expect(calls("get", "/public/community-agent")).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(screen.queryByTestId("chat-agent-dm-open")).toBeNull();
+  });
+
+  it("lists an existing agent DM with its badge, rates answers in it, and shows its thinking", async () => {
+    const agentDm = { id: "chan-ai", name: "Assistant", type: "dm", description: null, otherParticipant: null, dmKey: "agent:agent-1:account-1" };
+    installAdapter([
+      ...memberRoutes(),
+      channelsRoute([agentDm]),
+      messagesRoute([agentMessage()]),
+      get(/^\/public\/chat\/channels\/[^/]+\/pinned$/, () => []),
+      get("/public/chat/unread-counts", () => []),
+      get("/public/chat/dm/directory", () => []),
+      post("/public/chat/read-receipts", () => ({})),
+      ratingsRoute([{ entityId: "m-ai", feedback: null }]),
+      post("/public/community-agent/feedback", () => ({ id: "a", feedback: -1 })),
+    ]);
+    renderIn(<ChatRoom />);
+    // The DM row carries the badge, and the separate entry point is not repeated.
+    await waitFor(() => expect(screen.getAllByTestId("community-agent-badge").length).toBeGreaterThan(0));
+    expect(screen.queryByTestId("chat-agent-dm-open")).toBeNull();
+    fireEvent.click(screen.getByRole("button", { name: /Assistant/ }));
+
+    const bubble = await screen.findByTestId("chat-agent-message");
+    fireEvent.click(within(bubble).getByRole("button", { name: "Not helpful" }));
+    await waitFor(() => expect(calls("post", "/public/community-agent/feedback")).toHaveLength(1));
+    expect(calls("post", "/public/community-agent/feedback")[0].body).toEqual({
+      profileId: PROFILE_ID,
+      entityType: "chat_message",
+      entityId: "m-ai",
+      value: -1,
+    });
+
+    deliver("chatAgentThinking", { channelId: "chan-ai", parentMessageId: null, agentId: "agent-1", state: "thinking" });
+    expect(screen.getByTestId("community-agent-thinking").textContent).toContain("Assistant is thinking");
+    deliver("chatAgentThinking", { channelId: "chan-ai", parentMessageId: null, agentId: "agent-1", state: "done" });
+    expect(screen.queryByTestId("community-agent-thinking")).toBeNull();
+  });
+
+  it("a channel thread: thumbs on the answers the read returns, hydrated, even when the viewer started nothing", async () => {
+    const parent = agentMessage({ id: "m-root", channelId: "chan-1", senderAgentId: null, senderAccountId: "someone", senderFirstName: "Sam", content: "@Assistant when?" });
+    const answers = [
+      agentMessage({ id: "m-t1", channelId: "chan-1", parentMessageId: "m-root" }),
+      agentMessage({ id: "m-t2", channelId: "chan-1", parentMessageId: "m-root" }),
+    ];
+    installAdapter([
+      ...memberRoutes(),
+      get("/public/chat/messages/m-root/replies", () => ({ data: answers, total: 2, page: 1, limit: 50 })),
+      ratingsRoute([{ entityId: "m-t2", feedback: -1 }]),
+    ]);
+    renderIn(<ChatThreadPanel parentMessage={parent} socket={null} currentAccountId={ME.id} onClose={() => {}} border="1px solid" />);
+    await waitFor(() => expect(screen.getAllByTestId("community-agent-feedback")).toHaveLength(1));
+    expect(calls("get", RATINGS_PATH)[0].params).toEqual({ profileId: PROFILE_ID, entityType: "chat_message", entityIds: "m-t1,m-t2" });
+    const feedback = screen.getByTestId("community-agent-feedback");
+    expect(within(feedback).getByRole("button", { name: "Not helpful" }).getAttribute("aria-pressed")).toBe("true");
+  });
+
+  it("the agent DM: no thumbs on an answer the read does not return", async () => {
+    const agentDm = { id: "chan-ai", name: "Assistant", type: "dm", description: null, otherParticipant: null, dmKey: "agent:agent-1:account-1" };
+    installAdapter([
+      ...memberRoutes(),
+      channelsRoute([agentDm]),
+      messagesRoute([agentMessage()]),
+      get(/^\/public\/chat\/channels\/[^/]+\/pinned$/, () => []),
+      get("/public/chat/unread-counts", () => []),
+      get("/public/chat/dm/directory", () => []),
+      post("/public/chat/read-receipts", () => ({})),
+      ratingsRoute([]),
+    ]);
+    renderIn(<ChatRoom />);
+    await waitFor(() => expect(screen.getAllByTestId("community-agent-badge").length).toBeGreaterThan(0));
+    fireEvent.click(screen.getByRole("button", { name: /Assistant/ }));
+    const bubble = await screen.findByTestId("chat-agent-message");
+    await waitFor(() => expect(calls("get", RATINGS_PATH)).toHaveLength(1));
+    await new Promise((r) => setTimeout(r, 20));
+    expect(within(bubble).queryByTestId("community-agent-feedback")).toBeNull();
+  });
+});