test(features): cover extracted queue hooks and helpers

Add focused tests for the four units lifted in this PR:
- queueHelpers (formatTicketLabel / truncate / bandLabel)
- useBatchTriageManager (seed from visible queue + run + empty-input
  error)
- useDispatchManager (missing-item preview error + preview invoke
  payload + initial state)
- useQueueOperationHandlers (claim / resolve-reopen transitions +
  keyboard J/C shortcut + INPUT-target short circuit)

+15 tests.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: saagar210

src/features/revamp/screens/queueHelpers.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { bandLabel, formatTicketLabel, truncate } from "./queueHelpers";
+import type { QueueItem } from "../../inbox/queueModel";
+import type { SavedDraft } from "../../../types/workspace";
+
+function makeItem(
+  state: QueueItem["meta"]["state"],
+  owner: string,
+  isAtRisk = false,
+): QueueItem {
+  return {
+    draft: { id: "d", ticket_id: null } as unknown as SavedDraft,
+    meta: {
+      owner,
+      state,
+      priority: "normal",
+      updatedAt: "2026-04-01T00:00:00Z",
+    },
+    slaDueAt: "2026-04-02T00:00:00Z",
+    isAtRisk,
+  } as QueueItem;
+}
+
+describe("formatTicketLabel", () => {
+  it("prefers the ticket id when present", () => {
+    expect(
+      formatTicketLabel({
+        id: "abc12345678",
+        ticket_id: "INC-42",
+      } as SavedDraft),
+    ).toBe("INC-42");
+  });
+
+  it("falls back to a truncated draft id when there is no ticket id", () => {
+    expect(
+      formatTicketLabel({
+        id: "abcdef0123456789",
+        ticket_id: null,
+      } as SavedDraft),
+    ).toBe("Draft abcdef01");
+  });
+});
+
+describe("truncate", () => {
+  it("returns the original string when under the limit", () => {
+    expect(truncate("short", 10)).toBe("short");
+  });
+
+  it("adds an ellipsis when over the limit", () => {
+    expect(truncate("abcdefghij", 5)).toBe("abcde...");
+  });
+});
+
+describe("bandLabel", () => {
+  it("resolves the band from meta.state + owner + isAtRisk in priority order", () => {
+    expect(bandLabel(makeItem("resolved", "alice"))).toBe("Resolved");
+    expect(bandLabel(makeItem("open", "alice", true))).toBe("At Risk");
+    expect(bandLabel(makeItem("open", "unassigned"))).toBe("Unassigned");
+    expect(bandLabel(makeItem("in_progress", "alice"))).toBe("In Progress");
+    expect(bandLabel(makeItem("open", "alice"))).toBe("Open");
+  });
+});

src/features/revamp/screens/useBatchTriageManager.test.ts

@@ -0,0 +1,134 @@
+// @vitest-environment jsdom
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useBatchTriageManager } from "./useBatchTriageManager";
+import type { QueueItem } from "../../inbox/queueModel";
+import type { SavedDraft } from "../../../types/workspace";
+
+function makeItem(id: string, summary: string): QueueItem {
+  return {
+    draft: {
+      id,
+      ticket_id: `INC-${id}`,
+      summary_text: summary,
+      input_text: summary,
+    } as unknown as SavedDraft,
+    meta: {
+      owner: "alice",
+      state: "open",
+      priority: "normal",
+      updatedAt: "2026-04-01T00:00:00Z",
+    },
+    slaDueAt: "2026-04-02T00:00:00Z",
+    isAtRisk: false,
+  } as QueueItem;
+}
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("useBatchTriageManager", () => {
+  it("seeds the input from the first 25 filtered items", () => {
+    const { result } = renderHook(() =>
+      useBatchTriageManager({
+        filteredItems: [
+          makeItem("1", "VPN down"),
+          makeItem("2", "Password reset"),
+        ],
+        operatorName: "alice",
+        clusterTicketsForTriage: vi.fn(),
+        listRecentTriageClusters: vi.fn(async () => []),
+        setTriageHistory: vi.fn(),
+        logEvent: vi.fn(),
+        showSuccess: vi.fn(),
+        showError: vi.fn(),
+      }),
+    );
+
+    act(() => result.current.handleSeedBatchTriage());
+
+    expect(result.current.batchTriageInput).toBe(
+      "INC-1|VPN down\nINC-2|Password reset",
+    );
+  });
+
+  it("clusters tickets, refreshes history, and logs success", async () => {
+    const cluster = vi.fn(async () => [
+      {
+        cluster_key: "outage",
+        summary: "VPN outage",
+        ticket_count: 1,
+        ticket_ids: ["INC-1"],
+      },
+    ]);
+    const listRecent = vi.fn(async () => [
+      {
+        id: "c1",
+        cluster_key: "outage",
+        summary: "VPN outage",
+        ticket_count: 2,
+      } as unknown as never,
+    ]);
+    const setTriageHistory = vi.fn();
+    const showSuccess = vi.fn();
+    const showError = vi.fn();
+
+    const { result } = renderHook(() =>
+      useBatchTriageManager({
+        filteredItems: [],
+        operatorName: "alice",
+        clusterTicketsForTriage: cluster as never,
+        listRecentTriageClusters: listRecent as never,
+        setTriageHistory,
+        logEvent: vi.fn(),
+        showSuccess,
+        showError,
+      }),
+    );
+
+    act(() => {
+      result.current.setBatchTriageInput("INC-1|VPN outage");
+    });
+
+    await act(async () => {
+      await result.current.handleRunBatchTriage();
+    });
+
+    await waitFor(() => {
+      expect(setTriageHistory).toHaveBeenCalled();
+    });
+    expect(cluster).toHaveBeenCalledWith([
+      expect.objectContaining({ id: "INC-1", summary: "VPN outage" }),
+    ]);
+    expect(showSuccess).toHaveBeenCalledWith("Batch triage completed");
+    expect(showError).not.toHaveBeenCalled();
+  });
+
+  it("surfaces an error when the input is empty", async () => {
+    const showError = vi.fn();
+    const cluster = vi.fn();
+
+    const { result } = renderHook(() =>
+      useBatchTriageManager({
+        filteredItems: [],
+        operatorName: "alice",
+        clusterTicketsForTriage: cluster as never,
+        listRecentTriageClusters: vi.fn(async () => []),
+        setTriageHistory: vi.fn(),
+        logEvent: vi.fn(),
+        showSuccess: vi.fn(),
+        showError,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.handleRunBatchTriage();
+    });
+
+    expect(showError).toHaveBeenCalledWith(
+      "Add at least one ticket before running batch triage",
+    );
+    expect(cluster).not.toHaveBeenCalled();
+  });
+});

src/features/revamp/screens/useDispatchManager.test.ts

@@ -0,0 +1,122 @@
+// @vitest-environment jsdom
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useDispatchManager } from "./useDispatchManager";
+import type { QueueItem } from "../../inbox/queueModel";
+import type { SavedDraft } from "../../../types/workspace";
+
+// Gate the initial dispatch-history fetch off so the hook's useEffect short-
+// circuits synchronously. Handler-level tests exercise the real dispatch
+// functions through hook args.
+vi.mock("../../revamp", () => ({
+  resolveRevampFlags: () => ({
+    ASSISTSUPPORT_REVAMP_INBOX: true,
+    ASSISTSUPPORT_BATCH_TRIAGE: true,
+    ASSISTSUPPORT_COLLABORATION_DISPATCH: false,
+  }),
+}));
+
+function makeItem(): QueueItem {
+  return {
+    draft: {
+      id: "d1",
+      ticket_id: "INC-1",
+      input_text: "VPN outage",
+      summary_text: "VPN",
+    } as unknown as SavedDraft,
+    meta: {
+      owner: "alice",
+      state: "open",
+      priority: "normal",
+      updatedAt: "2026-04-01T00:00:00Z",
+    },
+    slaDueAt: "2026-04-02T00:00:00Z",
+    isAtRisk: false,
+  } as QueueItem;
+}
+
+// Stable listDispatchHistory reference shared across tests so the hook's
+// useEffect dependency never changes mid-test and can't drive a re-render loop.
+const stableListDispatchHistory = vi.fn(async () => []);
+
+describe("useDispatchManager", () => {
+  it("errors when previewing without a selected item", () => {
+    const showError = vi.fn();
+    const { result } = renderHook(() =>
+      useDispatchManager({
+        operatorName: "alice",
+        previewCollaborationDispatch: vi.fn(),
+        confirmCollaborationDispatch: vi.fn(),
+        cancelCollaborationDispatch: vi.fn(),
+        listDispatchHistory: stableListDispatchHistory,
+        logEvent: vi.fn(),
+        showSuccess: vi.fn(),
+        showError,
+      }),
+    );
+
+    act(() => {
+      result.current.handlePreviewDispatch(null);
+    });
+
+    expect(showError).toHaveBeenCalledWith(
+      "Select a work item before previewing a dispatch",
+    );
+  });
+
+  it("invokes previewCollaborationDispatch with the current item and dispatch target", async () => {
+    const previewCall = vi.fn(async () => ({
+      id: "dispatch-1",
+      integration_type: "jira",
+      destination_label: "Jira",
+      title: "Preview title",
+      status: "preview",
+      created_at: "2026-04-01T00:00:00Z",
+    }));
+
+    const { result } = renderHook(() =>
+      useDispatchManager({
+        operatorName: "alice",
+        previewCollaborationDispatch: previewCall as never,
+        confirmCollaborationDispatch: vi.fn(),
+        cancelCollaborationDispatch: vi.fn(),
+        listDispatchHistory: stableListDispatchHistory,
+        logEvent: vi.fn(),
+        showSuccess: vi.fn(),
+        showError: vi.fn(),
+      }),
+    );
+
+    act(() => {
+      result.current.handlePreviewDispatch(makeItem());
+    });
+
+    await waitFor(() => {
+      expect(previewCall).toHaveBeenCalledWith(
+        expect.objectContaining({
+          integrationType: "jira",
+          draftId: "d1",
+        }),
+      );
+    });
+  });
+
+  it("initializes with no dispatch preview or pending id", () => {
+    const { result } = renderHook(() =>
+      useDispatchManager({
+        operatorName: "alice",
+        previewCollaborationDispatch: vi.fn(),
+        confirmCollaborationDispatch: vi.fn(),
+        cancelCollaborationDispatch: vi.fn(),
+        listDispatchHistory: stableListDispatchHistory,
+        logEvent: vi.fn(),
+        showSuccess: vi.fn(),
+        showError: vi.fn(),
+      }),
+    );
+
+    expect(result.current.dispatchTarget).toBe("jira");
+    expect(result.current.dispatchPreview).toBeNull();
+    expect(result.current.pendingDispatchId).toBeNull();
+  });
+});