@stigmer/react 3.7.0 → 3.9.0

package/src/conversation/__tests__/a11y/conversation-surfaces.a11y.test.tsx

@@ -0,0 +1,235 @@
+// Accessibility audit — the conversation list pane and timeline view.
+//
+// Covers the populated inbox (attention badge, human-control caption,
+// channel filter, the wants-human filter control, both awaiting-reply
+// indicator strengths), the WhatsApp-style timeline (both bubble sides,
+// the two status axes, the visible receipt-failure explanation,
+// internal-lane system rows, the Slack honesty notice), the staff
+// composer with the closed-window advisory (T07 DD-014), and the empty
+// states including the filtered one — each in light + dark against the
+// shipped stylesheet.
+
+import { describe, it, afterEach, vi } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
+import {
+  ChannelConversationListFilter,
+  ChannelConversationSchema,
+  ConversationControl,
+  ConversationItemAuthor,
+  ConversationLane,
+  ConversationTimelineItemSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_io_pb";
+import { ChannelDeliveryStatus } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/delivery_pb";
+import { ChannelReceiptState } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/outbound_pb";
+import { ConversationComposer } from "../../ConversationComposer.js";
+import { ConversationListPane } from "../../ConversationListPane.js";
+import { ConversationTimelineView } from "../../ConversationTimelineView.js";
+import {
+  COLOR_MODES,
+  auditA11y,
+  renderAudited,
+  resetConversationAudit,
+} from "./harness.js";
+
+const NOW = new Date("2026-08-07T12:00:00Z");
+const noop = () => {};
+
+const channels = [
+  create(AgentChannelSchema, {
+    metadata: { id: "ach_wa", org: "acme", name: "support-line", slug: "support-line" },
+    spec: { providerConfig: { case: "whatsapp", value: {} } },
+  }),
+  create(AgentChannelSchema, {
+    metadata: { id: "ach_sl", org: "acme", name: "eng-help", slug: "eng-help" },
+    spec: { providerConfig: { case: "slack", value: {} } },
+  }),
+];
+
+const conversations = [
+  create(ChannelConversationSchema, {
+    agentChannelId: "ach_wa",
+    conversationKey: "15550001111",
+    org: "acme",
+    displayName: "Pat",
+    needsAttention: true,
+    attentionReason: "refund I cannot process",
+    // Agent-held and awaiting: the muted indicator strength.
+    awaitingReply: true,
+    lastActivityAt: timestampFromDate(new Date("2026-08-07T11:55:00Z")),
+  }),
+  create(ChannelConversationSchema, {
+    agentChannelId: "ach_wa",
+    conversationKey: "15550002222",
+    org: "acme",
+    control: ConversationControl.control_human,
+    controlledBy: "idt_staff",
+    // Human-held and awaiting: the strong indicator strength (F-13).
+    awaitingReply: true,
+    lastActivityAt: timestampFromDate(new Date("2026-08-07T09:00:00Z")),
+  }),
+];
+
+const timelineItems = [
+  create(ConversationTimelineItemSchema, {
+    itemId: "wa:1",
+    lane: ConversationLane.lane_public,
+    author: ConversationItemAuthor.author_customer,
+    text: "where is my order?",
+    at: timestampFromDate(new Date("2026-08-06T18:00:00Z")),
+  }),
+  create(ConversationTimelineItemSchema, {
+    itemId: "wa:2",
+    lane: ConversationLane.lane_public,
+    author: ConversationItemAuthor.author_customer,
+    providerMessageType: "image",
+    at: timestampFromDate(new Date("2026-08-07T08:59:00Z")),
+  }),
+  create(ConversationTimelineItemSchema, {
+    itemId: "ev:3",
+    lane: ConversationLane.lane_internal,
+    author: ConversationItemAuthor.author_agent,
+    text: "the member is asking about a refund I cannot process",
+    at: timestampFromDate(new Date("2026-08-07T09:00:00Z")),
+  }),
+  create(ConversationTimelineItemSchema, {
+    itemId: "dl:4",
+    lane: ConversationLane.lane_public,
+    author: ConversationItemAuthor.author_agent,
+    text: "checking with the team now",
+    deliveryStatus: ChannelDeliveryStatus.delivered,
+    receiptState: ChannelReceiptState.receipt_read,
+    at: timestampFromDate(new Date("2026-08-07T09:01:00Z")),
+  }),
+  create(ConversationTimelineItemSchema, {
+    itemId: "ob:5",
+    lane: ConversationLane.lane_public,
+    author: ConversationItemAuthor.author_teammate,
+    text: "I'll take this personally",
+    deliveryStatus: ChannelDeliveryStatus.delivered,
+    receiptState: ChannelReceiptState.receipt_failed,
+    // The T07 visible explanation line (DD-014 D-c) rides the audit.
+    receiptDetail:
+      "More than 24 hours have passed since the recipient last replied to the sender number.",
+    receiptErrorCode: 131047,
+    at: timestampFromDate(new Date("2026-08-07T09:02:00Z")),
+  }),
+  create(ConversationTimelineItemSchema, {
+    itemId: "ob:6",
+    lane: ConversationLane.lane_public,
+    author: ConversationItemAuthor.author_agent,
+    text: "a reminder that never went",
+    deliveryStatus: ChannelDeliveryStatus.suppressed,
+    at: timestampFromDate(new Date("2026-08-07T09:03:00Z")),
+  }),
+];
+
+const listBaseProps = {
+  isLoading: false,
+  error: null,
+  hasMore: true,
+  loadMore: noop,
+  isLoadingMore: false,
+  channels,
+  channelFilter: "",
+  onChannelFilterChange: noop,
+  onSelect: noop,
+  now: NOW,
+};
+
+const timelineBaseProps = {
+  isLoading: false,
+  error: null,
+  hasOlder: true,
+  loadOlder: noop,
+  isLoadingOlder: false,
+  now: NOW,
+};
+
+afterEach(() => {
+  resetConversationAudit();
+  vi.restoreAllMocks();
+});
+
+describe("Conversation surfaces a11y", () => {
+  it.each(COLOR_MODES)("populated inbox with badges, indicators, and filters (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationListPane
+        {...listBaseProps}
+        conversations={conversations}
+        onFilterChange={noop}
+        selected={{ agentChannelId: "ach_wa", conversationKey: "15550001111" }}
+      />,
+      mode,
+    );
+    await auditA11y(container, `conversation list · ${mode}`);
+  });
+
+  it.each(COLOR_MODES)("inbox empty states (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationListPane
+        {...listBaseProps}
+        conversations={[]}
+        channels={[]}
+        hasMore={false}
+        selected={null}
+      />,
+      mode,
+    );
+    await auditA11y(container, `conversation list empty · ${mode}`);
+  });
+
+  it.each(COLOR_MODES)("filtered inbox empty state (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationListPane
+        {...listBaseProps}
+        conversations={[]}
+        hasMore={false}
+        filter={ChannelConversationListFilter.filter_wants_human}
+        onFilterChange={noop}
+        selected={null}
+      />,
+      mode,
+    );
+    await auditA11y(container, `filtered conversation list empty · ${mode}`);
+  });
+
+  it.each(COLOR_MODES)("timeline with both sides, status axes, internal rows (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationTimelineView
+        {...timelineBaseProps}
+        items={timelineItems}
+        provider="whatsapp"
+      />,
+      mode,
+    );
+    await auditA11y(container, `conversation timeline · ${mode}`);
+  });
+
+  it.each(COLOR_MODES)("composer with the closed-window advisory (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationComposer
+        onSend={() => Promise.reject(new Error("never sent in an audit"))}
+        isSending={false}
+        disabledReason={null}
+        advisory="WhatsApp closes free-form replies 24 hours after the customer's last message — a reply sent now will probably fail. The window reopens when the customer writes again."
+      />,
+      mode,
+    );
+    await auditA11y(container, `composer with advisory · ${mode}`);
+  });
+
+  it.each(COLOR_MODES)("timeline Slack honesty notice (%s)", async (mode) => {
+    const container = renderAudited(
+      <ConversationTimelineView
+        {...timelineBaseProps}
+        items={[]}
+        hasOlder={false}
+        provider="slack"
+      />,
+      mode,
+    );
+    await auditA11y(container, `slack timeline notice · ${mode}`);
+  });
+});

package/src/conversation/__tests__/a11y/harness.tsx

@@ -0,0 +1,100 @@
+// Shared harness for the conversation surface's browser-mode a11y audits.
+//
+// The audit policy (WCAG 2.0 A/AA via axe-core, fail on critical/serious,
+// log the rest, `color-contrast` advisory pending the app-wide token
+// contrast pass) is the workspace suite's — see
+// `src/workspace/__tests__/a11y/harness.tsx`, the canonical statement of
+// the policy and its rationale. This is the SECOND a11y suite; per the
+// house third-call-site rule the shared extraction happens when a third
+// surface needs it, not speculatively here.
+
+import "../../../../dist/styles.css";
+
+import { render, cleanup } from "@testing-library/react";
+import type { ReactElement } from "react";
+import axe from "axe-core";
+import { expect } from "vitest";
+import type { Stigmer } from "@stigmer/sdk";
+import { StigmerContext } from "../../../context.js";
+
+/** The color modes every state is audited under. */
+export const COLOR_MODES = ["light", "dark"] as const;
+export type ColorMode = (typeof COLOR_MODES)[number];
+
+/** See the workspace harness for why contrast stays advisory for now. */
+const ADVISORY_RULE_IDS = new Set<string>(["color-contrast"]);
+
+// The audited components are presentational (data arrives as props), so no
+// client method is ever invoked — but `useStigmer` throws outside a
+// provider, so a stub context is still required.
+const stubClient = {} as unknown as Stigmer;
+
+/**
+ * Render `ui` inside a themed `.stgm` container for the given color mode,
+ * attached to the live DOM so both `screen` queries and axe can see it.
+ */
+export function renderAudited(ui: ReactElement, mode: ColorMode): HTMLElement {
+  const container = document.createElement("div");
+  container.className = "stgm";
+  container.setAttribute("data-stgm-color-mode", mode);
+  container.style.background = "var(--stgm-background)";
+  container.style.color = "var(--stgm-foreground)";
+  // A real box for the flex/scroll panes to lay out in.
+  container.style.height = "720px";
+  container.style.width = "1024px";
+  document.body.appendChild(container);
+
+  render(<StigmerContext.Provider value={stubClient}>{ui}</StigmerContext.Provider>, {
+    container,
+  });
+  return container;
+}
+
+function summarize(violations: axe.Result[]): string {
+  return violations
+    .map((v) => {
+      const nodes = v.nodes
+        .slice(0, 5)
+        .map((n) => `    · ${n.target.join(" ")}\n      ${n.html.slice(0, 160)}`)
+        .join("\n");
+      return `  [${v.impact}] ${v.id}: ${v.help} (${v.nodes.length} node(s))\n${nodes}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Run the WCAG 2.0 A/AA audit over `container`. Fails the test on any
+ * critical/serious violation; logs moderate/minor and advisory rules.
+ */
+export async function auditA11y(container: HTMLElement, label: string): Promise<void> {
+  const results = await axe.run(container, {
+    runOnly: { type: "tag", values: ["wcag2a", "wcag2aa"] },
+  });
+
+  const serious = results.violations.filter(
+    (v) =>
+      (v.impact === "critical" || v.impact === "serious") &&
+      !ADVISORY_RULE_IDS.has(v.id),
+  );
+  const advisory = results.violations.filter(
+    (v) =>
+      ADVISORY_RULE_IDS.has(v.id) ||
+      v.impact === "moderate" ||
+      v.impact === "minor",
+  );
+
+  if (advisory.length > 0) {
+    console.warn(`[a11y: ${label}] non-blocking violations:\n${summarize(advisory)}`);
+  }
+
+  expect(
+    serious,
+    `[a11y: ${label}] critical/serious axe violations:\n${summarize(serious)}`,
+  ).toHaveLength(0);
+}
+
+/** Reset cross-test state; call in `afterEach`. */
+export function resetConversationAudit(): void {
+  cleanup();
+  document.querySelectorAll(".stgm").forEach((node) => node.remove());
+}

package/src/conversation/__tests__/conversation-tooltips.layout.test.tsx

@@ -0,0 +1,167 @@
+// Tooltip behavior for the conversation status glyphs (F-18), in a real
+// Chromium. The fix replaced native `title` hints (OS-delayed, invisible
+// to keyboard and touch, dead on disabled buttons) with the house
+// tooltip. The fast happy-dom suite pins the STRUCTURE (sr-only names
+// kept, no titles, no new tab stops); it cannot honestly pin the
+// REVEAL — Base UI opens on real pointer movement, which only a real
+// browser delivers. This suite proves a mouse user actually gets the
+// explanation. First real-browser tooltip coverage in the SDK; the
+// WorkspaceSidebar recents tooltip rides the same primitive.
+
+import "../../../dist/styles.css";
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, cleanup } from "@testing-library/react";
+import { userEvent } from "@vitest/browser/context";
+import type { ReactElement } from "react";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import {
+  ChannelConversationSchema,
+  ConversationItemAuthor,
+  ConversationLane,
+  ConversationTimelineItemSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_io_pb";
+import { ChannelDeliveryStatus } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/delivery_pb";
+import { ChannelReceiptState } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/outbound_pb";
+import { ConversationListPane } from "../ConversationListPane.js";
+import { ConversationTimelineView } from "../ConversationTimelineView.js";
+
+const NOW = new Date("2026-08-07T12:00:00Z");
+
+/**
+ * A themed, sized box so hover geometry is real (the F-09 suite's
+ * shape) — narrow enough to fit the headless viewport, because a
+ * right-aligned business bubble in a pane wider than the viewport puts
+ * its receipt tick off-screen where a pointer cannot rest on it.
+ */
+function renderInPane(ui: ReactElement) {
+  const pane = document.createElement("div");
+  pane.className = "stgm";
+  pane.style.height = "360px";
+  pane.style.width = "320px";
+  pane.style.display = "flex";
+  pane.style.flexDirection = "column";
+  document.body.appendChild(pane);
+  render(ui, { container: pane });
+  return pane;
+}
+
+/**
+ * Hover `trigger` and wait for `hint` to appear in the PORTAL — i.e. in
+ * a `document.body` child other than the pane, proving the tooltip
+ * escaped the scroll container — respecting Base UI's open delay.
+ */
+async function expectHoverReveals(pane: HTMLElement, trigger: Element, hint: string) {
+  await userEvent.hover(trigger);
+  await vi.waitFor(
+    () => {
+      const portaled = Array.from(document.body.children)
+        .filter((node) => node !== pane)
+        .map((node) => node.textContent ?? "")
+        .join(" ");
+      expect(portaled).toContain(hint);
+    },
+    { timeout: 3000, interval: 50 },
+  );
+  await userEvent.unhover(trigger);
+}
+
+afterEach(() => {
+  cleanup();
+  document.querySelectorAll(".stgm").forEach((node) => node.remove());
+});
+
+describe("conversation status tooltips (F-18)", () => {
+  it("reveals the receipt and failure explanations on hover — with zero native titles", async () => {
+    const pane = renderInPane(
+      <ConversationTimelineView
+        items={[
+          create(ConversationTimelineItemSchema, {
+            itemId: "ob:read",
+            lane: ConversationLane.lane_public,
+            author: ConversationItemAuthor.author_teammate,
+            text: "your table is ready",
+            deliveryStatus: ChannelDeliveryStatus.delivered,
+            receiptState: ChannelReceiptState.receipt_read,
+            at: timestampFromDate(new Date("2026-08-07T11:58:00Z")),
+          }),
+          create(ConversationTimelineItemSchema, {
+            itemId: "dl:failed",
+            lane: ConversationLane.lane_public,
+            author: ConversationItemAuthor.author_agent,
+            text: "a reply that never arrived",
+            deliveryStatus: ChannelDeliveryStatus.failed,
+            at: timestampFromDate(new Date("2026-08-07T11:59:00Z")),
+          }),
+        ]}
+        isLoading={false}
+        error={null}
+        hasOlder={false}
+        loadOlder={() => {}}
+        isLoadingOlder={false}
+        provider="whatsapp"
+        now={NOW}
+      />,
+    );
+
+    expect(pane.querySelector("[title]")).toBeNull();
+
+    // The read tick's trigger: the outermost span whose text content is
+    // the sr-only name (document order puts the trigger before the
+    // sr-only span it contains).
+    const readTrigger = Array.from(pane.querySelectorAll("span")).find(
+      (el) => el.textContent === "Read",
+    );
+    await expectHoverReveals(pane, readTrigger!, "Read by the customer");
+
+    // The failed attempt keeps its visible short label and reveals the
+    // longer explanation on hover.
+    const failed = Array.from(pane.querySelectorAll("span")).find((el) =>
+      el.textContent?.includes("Not delivered"),
+    );
+    await expectHoverReveals(
+      pane,
+      failed!,
+      "The platform could not deliver this message",
+    );
+  });
+
+  it("reveals the attention reason on the inbox badge without focusable clutter", async () => {
+    const pane = renderInPane(
+      <ConversationListPane
+        conversations={[
+          create(ChannelConversationSchema, {
+            agentChannelId: "ach_wa",
+            conversationKey: "15550001111",
+            org: "acme",
+            displayName: "Pat",
+            needsAttention: true,
+            attentionReason: "refund I cannot process",
+          }),
+        ]}
+        isLoading={false}
+        error={null}
+        hasMore={false}
+        loadMore={() => {}}
+        isLoadingMore={false}
+        channels={[]}
+        channelFilter=""
+        onChannelFilterChange={() => {}}
+        selected={null}
+        onSelect={() => {}}
+        now={NOW}
+      />,
+    );
+
+    expect(pane.querySelector("[title]")).toBeNull();
+    // The trigger span stays out of the tab order (structure is pinned
+    // in the fast suite; re-asserted here against the real DOM).
+    expect(pane.querySelectorAll("li [tabindex]")).toHaveLength(0);
+
+    const badgeTrigger = Array.from(pane.querySelectorAll("span")).find(
+      (el) => el.textContent === "Needs attention: refund I cannot process",
+    );
+    await expectHoverReveals(pane, badgeTrigger!, "refund I cannot process");
+  });
+});

package/src/conversation/__tests__/conversationPollingComposition.test.tsx

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import {
+  ChannelConversationSchema,
+  ConversationControl,
+} from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { advanceInSlices } from "../../internal/__tests__/fake-timer-slices";
+import { useConversation } from "../useConversation";
+import { useConversationTimeline } from "../useConversationTimeline";
+import { useConversationsWantsHumanCount } from "../useConversationsWantsHumanCount";
+
+/**
+ * The F-14 composition net (channel-conversations T06): the open
+ * conversation mounts BOTH `useConversation` (the row poll, a
+ * hand-rolled loop with stable deps) and `useConversationTimeline` (a
+ * `useFetch` poll) in one component — the `ConversationsWorkbench`
+ * shape. The row poll re-renders that component at fetch-start and at
+ * settle every cycle; the timeline's poll must survive those renders.
+ *
+ * In production both hooks default to 5s and the timeline starved
+ * deterministically. The intervals here are OFFSET (row 3s, timeline
+ * 5s) because aligned periods mask the defect under fake timers: two
+ * timers sharing a phase both fire inside the same advanced instant,
+ * before React commits the re-render that would tear the poll timer
+ * down. With the row poll at 3s, the timeline's 5s window can never
+ * elapse untouched — unless its timer keeps its phase across renders,
+ * which is the behavior this test pins.
+ */
+
+function conversationRow() {
+  return create(ChannelConversationSchema, {
+    agentChannelId: "ach_1",
+    conversationKey: "15550001111",
+    org: "acme",
+    displayName: "Pat",
+    control: ConversationControl.control_agent,
+    lastActivityAt: timestampFromDate(new Date("2026-08-07T11:00:00Z")),
+  });
+}
+
+function createMockStigmer() {
+  return {
+    agentChannel: {
+      getConversation: vi.fn().mockResolvedValue(conversationRow()),
+      getTimeline: vi.fn().mockResolvedValue({ items: [], nextPageToken: "" }),
+      listConversations: vi.fn().mockResolvedValue({ items: [], totalCount: 0 }),
+    },
+  };
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { readonly children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+describe("conversation polling composition (F-14)", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("the timeline keeps polling under the row poll's render cadence", async () => {
+    const client = createMockStigmer();
+    renderHook(
+      () => {
+        const detail = useConversation("ach_1", "15550001111", {
+          refetchIntervalMs: 3000,
+        });
+        const timeline = useConversationTimeline("ach_1", "15550001111", {
+          refetchIntervalMs: 5000,
+        });
+        return { detail, timeline };
+      },
+      { wrapper: wrapper(client) },
+    );
+
+    // Flush the initial fetches of both hooks.
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(client.agentChannel.getConversation).toHaveBeenCalledTimes(1);
+    expect(client.agentChannel.getTimeline).toHaveBeenCalledTimes(1);
+
+    // 15 seconds: the row poll fires at 3s, 6s, 9s, 12s, 15s — each
+    // firing re-renders the component twice (fetch-start and settle).
+    // The timeline poll must still fire at 5s, 10s, and 15s.
+    await advanceInSlices(15_000);
+    expect(client.agentChannel.getConversation).toHaveBeenCalledTimes(6);
+    expect(client.agentChannel.getTimeline).toHaveBeenCalledTimes(4);
+  });
+
+  it("the wants-human count keeps polling under the row poll's render cadence (the fourth poller)", async () => {
+    // T05's badge hook joins the same composition (the console mounts
+    // the sidebar beside the open conversation), so it inherits the
+    // F-14 exposure by construction: every row-poll firing re-renders,
+    // and a timer keyed on identity would never complete a period.
+    // Offset intervals for the same reason as above — aligned periods
+    // mask the defect under fake timers.
+    const client = createMockStigmer();
+    renderHook(
+      () => {
+        const detail = useConversation("ach_1", "15550001111", {
+          refetchIntervalMs: 3000,
+        });
+        const count = useConversationsWantsHumanCount("acme", {
+          refetchIntervalMs: 7000,
+        });
+        return { detail, count };
+      },
+      { wrapper: wrapper(client) },
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(client.agentChannel.listConversations).toHaveBeenCalledTimes(1);
+
+    // 21 seconds: the row poll fires at 3s..21s (7 firings, each a
+    // double re-render); the count poll must still fire at 7s, 14s, 21s.
+    await advanceInSlices(21_000);
+    expect(client.agentChannel.listConversations).toHaveBeenCalledTimes(4);
+  });
+});