From 1485d3de1b305d9862f724c662b5740ef9ae99db Mon Sep 17 00:00:00 2001
From: Dotta <34892728+cryppadotta@users.noreply.github.com>
Date: Fri, 6 Nov 2026 12:00:50 -0600
Subject: [PATCH] fix(ui): hold announcements until the onboarding first task
 is finished (#19514)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work.
> - A new user's first session is the onboarding first task. The agent
asks its onboarding questions in that task thread.
> - The app also shows an optional in-app announcement. The live feed
now serves "Introducing Connectors" (`2026-09-14-connectors`).
> - The announcement well only waits while the onboarding wizard dialog
is open. It shows 3 seconds after the user lands on the first task.
> - In the Nov 5 cloud onboarding test (Claude API path), the tester
said: "Don't show the connectors upsell until the second session. It's
blocking the user flyout and potentially the onboarding questions."
> - This pull request holds announcements until the company's onboarding
first task is done or cancelled.
> - The benefit is that a new user sees the onboarding questions and the
account menu without an upsell on top of them.

## Linked Issues or Issue Description

Refs #19511 (places the card in the desktop sidebar, above the account
menu. That PR keeps the card off the account menu after onboarding. This
PR adds the first-session gate that #19511 leaves open.)

**What happened?**
On a new company's onboarding first task, the "Introducing Connectors"
card shows 3 seconds after the page loads. At 1440x900 the card (352x346
px, bottom-left, z-40) covers the sidebar account menu trigger and the
left edge of the task composer.

**Expected behavior**
Optional announcements do not show in the first session, while the
onboarding first task is open.

**Steps to reproduce**
1. Create a new company through onboarding. The wizard creates the
onboarding first task.
2. Open the first task at 1440x900 and wait 3 seconds.
3. See the announcement card on top of the account menu and the
composer.

**Paperclip version or commit**
`master` at 819420a60a.

## What Changed

- `AnnouncementWell` reads the company's onboarding first task
(`originKind=onboarding_first_task`, `limit=1`) with React Query under
`["issues", companyId, "onboarding-first-task"]`. Issue live-update
invalidation of `["issues", companyId]` refreshes it.
- The well stays disabled while that task is not `done` or `cancelled`.
While the read is loading or after it fails, the optional card stays
hidden. A company that never had an onboarding first task is not gated.
- "First session" uses the existing `origin_kind` marker. There is no
schema change.
- New e2e spec `tests/e2e/announcement-first-session.spec.ts` with a
mocked feed that copies the live connectors entry. It checks that the
card is absent while the onboarding first task is open. Then it marks
the task done on the same page and checks that the card appears without
a reload (a positive control for the feed mock and the live refresh
path).
- New unit test `AnnouncementWell.onboarding.test.tsx`. It covers open,
finished, no first task, read failure, and the open-to-done transition
after `["issues", companyId]` is invalidated.
`AnnouncementWell.test.tsx` now gives the well a `QueryClient` with a
finished onboarding state.

## Verification

Red on `master` (819420a60a), before the fix. Vitest:

```
cd ui && npx vitest run src/components/AnnouncementWell.onboarding.test.tsx
     × stays hidden while the onboarding first task is open
     × stays hidden when onboarding state cannot be read
      Tests  2 failed | 1 passed (3)
AssertionError: expected true to be false
```

Red on `master`, Playwright at 1440x900 (an earlier draft of the spec
also had a placement check, recorded here as evidence for the flyout
part of the report):

```
✘ announcement-first-session.spec.ts › a brand-new company with its onboarding task open does not show the upsell
    Error: expect(locator).toHaveCount(expected) failed
    Locator:  getByRole('complementary', { name: 'Paperclip announcements' })
    Expected: 0
    Received: 1
✘ … where the upsell shows, it does not cover the account menu or its flyout
    Error: well {"x":12,"y":542,"width":352,"height":346} covers account trigger {"x":20,"y":856,"width":166,"height":36}
```

Green after the fix, merged with current `master` (f7070d68b5), with the
in-page positive control:

```
✓ announcement-first-session.spec.ts › a brand-new company with its onboarding task open does not show the upsell (10.1s)
  1 passed

cd ui && npx vitest run src/components/AnnouncementWell.onboarding.test.tsx src/components/AnnouncementWell.test.tsx
      Tests  6 passed (6)

cd ui && npx vitest run src/components/AnnouncementWell.onboarding.test.tsx src/components/AnnouncementWell.test.tsx \
  src/components/AnnouncementCard.test.tsx src/hooks/useAnnouncement.test.tsx src/components/SidebarAccountMenu.test.tsx src/components/Layout.test.tsx
 Test Files  6 passed (6)
      Tests  95 passed (95)
```

- `pnpm check:token-gates`: All gates clean.
- UI `tsc --noEmit`: no errors in app code. The only errors are the
git-ignored, generated Storybook catalog files.
- CI note: the first CI run had three jobs fail with "The self-hosted
runner lost communication with the server" (server tests 12/12, Runner
vitest package, e2e shard 5/8). These are infra flakes. I reran them.
- Local e2e note: two runs could not start the server because embedded
PostgreSQL ports were in use by parallel e2e runs on the same machine. A
rerun passed. This is not related to the change.

Before (master): the card covers the account menu and the composer on
the onboarding first task.

![before: onboarding first
task](https://raw.githubusercontent.com/paperclipai/paperclip/c97519868225b0c206cf95fa3fb7150287c88116/n13-before-onboarding-task.png)

After: no card on the onboarding first task. The account menu and the
composer are clear.

![after: onboarding first
task](https://raw.githubusercontent.com/paperclipai/paperclip/c97519868225b0c206cf95fa3fb7150287c88116/n13-after-onboarding-task.png)

## Risks

- Low risk. The change only hides optional content.
- A user who never finishes or cancels the onboarding first task does
not see announcements in that company. This is the intended trade-off
for "not in the first session". Closing the task shows them again.
- The well makes one extra small issues read (`limit=1`) per company. It
is cached for 60 seconds.
- `AnnouncementWell.tsx` also changes in #19511. Whichever PR lands
second resolves a small conflict in the `enabled` condition and the
`<aside>` placement.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, used through Claude
Code with tool use (shell, file edits, Playwright, Vitest).

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/e2e/announcement-first-session.spec.ts  | 105 ++++++++++++++++++
 .../AnnouncementWell.onboarding.test.tsx      |  76 +++++++++++++
 ui/src/components/AnnouncementWell.test.tsx   |   8 +-
 ui/src/components/AnnouncementWell.tsx        |  26 ++++-
 ui/src/lib/queryKeys.ts                       |   2 +
 5 files changed, 215 insertions(+), 2 deletions(-)
 create mode 100644 tests/e2e/announcement-first-session.spec.ts
 create mode 100644 ui/src/components/AnnouncementWell.onboarding.test.tsx

diff --git a/tests/e2e/announcement-first-session.spec.ts b/tests/e2e/announcement-first-session.spec.ts
new file mode 100644
index 00000000000..265b7924219
--- /dev/null
+++ b/tests/e2e/announcement-first-session.spec.ts
@@ -0,0 +1,105 @@
+import { test, expect, request as pwRequest, type APIRequestContext, type Page } from "@playwright/test";
+
+/**
+ * E2E (N-13): the in-app announcement well ("Introducing Connectors" upsell)
+ *
+ * stays hidden while a new company's onboarding first task is open, so it
+ * cannot cover the onboarding questions or the account menu in the user's
+ * first session. Placement (never covering the account menu once shown) is
+ * covered by announcement-placement.spec.ts.
+ *
+ * The public feed is mocked so the spec does not depend on what the live feed
+ * is publishing; the card mirrors the real 2026-09-14-connectors entry.
+ */
+
+const PORT = Number(process.env.PAPERCLIP_E2E_PORT ?? 3199);
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const ANNOUNCEMENT_ID = "e2e-n13-connectors";
+const SETTLE_WAIT_MS = 4_500; // ANNOUNCEMENT_SETTLE_MS (3 s) plus slack.
+const ONE_PIXEL_PNG = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
+  "base64",
+);
+
+async function createCompany(board: APIRequestContext, name: string) {
+  const res = await board.post(`${BASE_URL}/api/companies`, { data: { name: `${name}-${Date.now()}` } });
+  if (!res.ok()) throw new Error(`POST /api/companies → ${res.status()}: ${await res.text()}`);
+  const company = await res.json();
+  // A company without agents lands on "Create your first agent"; add one so the normal shell renders.
+  const agentRes = await board.post(`${BASE_URL}/api/companies/${company.id}/agents`, {
+    data: { name: "Chief of staff", role: "ceo", adapterType: "process", adapterConfig: { command: "true" } },
+  });
+  if (!agentRes.ok()) throw new Error(`POST agents → ${agentRes.status()}: ${await agentRes.text()}`);
+  return { id: company.id as string, prefix: (company.issuePrefix ?? company.prefix) as string };
+}
+
+async function createIssue(board: APIRequestContext, companyId: string, data: Record<string, unknown>) {
+  const res = await board.post(`${BASE_URL}/api/companies/${companyId}/issues`, { data });
+  if (!res.ok()) throw new Error(`POST issues → ${res.status()}: ${await res.text()}`);
+  return res.json() as Promise<{ id: string; identifier: string; originKind: string | null }>;
+}
+
+async function mockAnnouncementFeed(page: Page) {
+  await page.route("**/api/announcements/current", (route) => route.fulfill({ json: {
+    id: ANNOUNCEMENT_ID,
+    eyebrow: "Introducing Connectors",
+    title: "Give your agents the access they need",
+    description: "Connect Gmail, GitHub, Notion, and more. Choose which agents get access, which accounts they use, and which actions they can take.",
+    image: { path: `assets/${"a".repeat(64)}.png`, alt: "Paperclip agents with their own sets of connected apps." },
+    primaryAction: { kind: "route", label: "Explore connectors", path: "/apps" },
+  } }));
+  await page.route(`**/api/announcements/${ANNOUNCEMENT_ID}/image`, (route) =>
+    route.fulfill({ contentType: "image/png", body: ONE_PIXEL_PNG }));
+  await page.route(`**/api/announcements/${ANNOUNCEMENT_ID}/dismiss`, (route) => route.fulfill({ status: 204 }));
+  await page.route("**/api/workspace-preferences/me", (route) => route.fulfill({ json: {
+    userId: "local-board", coordinatorWorkspaceEnabled: false, updatedAt: null,
+  } }));
+  await page.addInitScript(() => {
+    for (const key of Object.keys(window.localStorage)) {
+      if (key.includes("announcement")) window.localStorage.removeItem(key);
+    }
+  });
+}
+
+test.describe("Announcement well (N-13)", () => {
+  let board: APIRequestContext;
+  const companyIds: string[] = [];
+
+  test.beforeAll(async () => {
+    board = await pwRequest.newContext({ baseURL: BASE_URL });
+  });
+
+  test.afterAll(async () => {
+    for (const id of companyIds) await board.delete(`${BASE_URL}/api/companies/${id}`).catch(() => {});
+    await board.dispose();
+  });
+
+  test.beforeEach(async ({ page }) => {
+    await page.setViewportSize({ width: 1440, height: 900 });
+    await mockAnnouncementFeed(page);
+  });
+
+  test("a brand-new company with its onboarding task open does not show the upsell", async ({ page }) => {
+    const company = await createCompany(board, "E2E-N13-Onboarding");
+    companyIds.push(company.id);
+    const firstTask = await createIssue(board, company.id, {
+      title: "Plan our launch", status: "todo", onboardingFirstTask: true,
+    });
+    expect(firstTask.originKind).toBe("onboarding_first_task");
+
+    await page.goto(`/${company.prefix}/issues/${firstTask.identifier}`);
+    await expect(page.getByRole("button", { name: "Open account menu" })).toBeVisible();
+    await page.waitForTimeout(SETTLE_WAIT_MS);
+    await page.screenshot({ path: test.info().outputPath("onboarding-task.png") });
+    const well = page.getByRole("complementary", { name: "Paperclip announcements" });
+    await expect(well).toHaveCount(0);
+
+    // Positive control on the same page: once onboarding finishes, the same
+    // mocked announcement renders without a reload. This proves the absence
+    // above comes from the onboarding gate, not from a broken feed mock.
+    const finish = await board.patch(`${BASE_URL}/api/issues/${firstTask.id}`, { data: { status: "done" } });
+    if (!finish.ok()) throw new Error(`PATCH issue → ${finish.status()}: ${await finish.text()}`);
+    await expect(well).toBeVisible({ timeout: 20_000 });
+    await expect(well.getByRole("link", { name: "Explore connectors" })).toBeVisible();
+  });
+});
diff --git a/ui/src/components/AnnouncementWell.onboarding.test.tsx b/ui/src/components/AnnouncementWell.onboarding.test.tsx
new file mode 100644
index 00000000000..f306991daa5
--- /dev/null
+++ b/ui/src/components/AnnouncementWell.onboarding.test.tsx
@@ -0,0 +1,76 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { HealthStatus } from "@/api/health";
+import { AnnouncementWell } from "./AnnouncementWell";
+import { announcementPreview } from "@/lib/announcement-preview";
+
+// N-13: the connectors announcement must not appear in a new user's first
+// session, i.e. while the company's onboarding first task is still open.
+const state = vi.hoisted(() => ({ list: vi.fn() }));
+vi.mock("@/api/companies-query", () => ({ useAccountIdentity: () => ({ userId: "alice", settled: true }) }));
+vi.mock("@/context/CompanyContext", () => ({ useCompany: () => ({ selectedCompanyId: "company", loading: false }) }));
+vi.mock("@/context/DialogContext", () => ({ useDialogState: () => ({ onboardingOpen: false }) }));
+vi.mock("@/context/ToastContext", () => ({ useOptionalToastActions: () => null, useOptionalToastState: () => [] }));
+vi.mock("@/api/issues", () => ({ issuesApi: { list: state.list } }));
+vi.mock("@/hooks/useAnnouncement", () => ({ useAnnouncement: (options: { enabled: boolean }) => ({
+  announcement: options.enabled ? announcementPreview : null, dismiss: vi.fn(),
+}) }));
+vi.mock("./AnnouncementCard", () => ({ AnnouncementCard: () => <p>Announcement fixture</p> }));
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+const firstTask = (status: string) => ({ id: "issue-1", companyId: "company", originKind: "onboarding_first_task", status });
+
+describe("announcement well during onboarding", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+  const health = { deploymentMode: "authenticated" } as HealthStatus;
+  const visible = () => Boolean(container.querySelector('[aria-label="Paperclip announcements"]'));
+  let client: QueryClient;
+  const flush = async () => { await act(async () => { await new Promise((resolve) => setTimeout(resolve, 0)); }); };
+  const render = async () => {
+    client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    await act(async () => root.render(<QueryClientProvider client={client}><AnnouncementWell health={health} /></QueryClientProvider>));
+    await act(async () => { await new Promise((resolve) => setTimeout(resolve, 0)); });
+  };
+  beforeEach(() => {
+    state.list.mockReset();
+    container = document.createElement("div"); document.body.append(container); root = createRoot(container);
+  });
+  afterEach(async () => { await act(async () => root.unmount()); container.remove(); });
+
+  it("stays hidden while the onboarding first task is open", async () => {
+    state.list.mockResolvedValue([firstTask("todo")]);
+    await render();
+    expect(visible()).toBe(false);
+  });
+
+  it("shows once the onboarding first task is finished, or when the company never had one", async () => {
+    state.list.mockResolvedValue([firstTask("done")]);
+    await render();
+    expect(visible()).toBe(true);
+    await act(async () => root.unmount()); root = createRoot(container);
+    state.list.mockResolvedValue([]);
+    await render();
+    expect(visible()).toBe(true);
+  });
+
+  it("shows without a reload once the open onboarding task finishes and company issues refresh", async () => {
+    state.list.mockResolvedValue([firstTask("todo")]);
+    await render();
+    expect(visible()).toBe(false);
+    state.list.mockResolvedValue([firstTask("done")]);
+    // Issue live updates invalidate the company's issue queries by this prefix.
+    await act(async () => { await client.invalidateQueries({ queryKey: ["issues", "company"] }); });
+    await flush();
+    expect(visible()).toBe(true);
+  });
+
+  it("stays hidden when onboarding state cannot be read", async () => {
+    state.list.mockRejectedValue(new Error("offline"));
+    await render();
+    expect(visible()).toBe(false);
+  });
+});
diff --git a/ui/src/components/AnnouncementWell.test.tsx b/ui/src/components/AnnouncementWell.test.tsx
index ebf0a0fabff..0a4930cfebf 100644
--- a/ui/src/components/AnnouncementWell.test.tsx
+++ b/ui/src/components/AnnouncementWell.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment jsdom
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { HealthStatus } from "@/api/health";
 import { AnnouncementWell } from "./AnnouncementWell";
@@ -18,6 +19,7 @@ vi.mock("@/hooks/useAnnouncement", () => ({ useAnnouncement: (options: { enabled
   state.hook(options);
   return { announcement: options.enabled ? announcementPreview : null, dismiss: state.dismiss };
 } }));
+vi.mock("@/api/issues", () => ({ issuesApi: { list: vi.fn().mockResolvedValue([]) } }));
 vi.mock("./AnnouncementCard", () => ({ AnnouncementCard: ({ onDismiss }: { onDismiss: () => void }) => <button onClick={onDismiss}>Dismiss fixture</button> }));
 (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
 
@@ -25,12 +27,16 @@ describe("announcement placement gates", () => {
   let container: HTMLDivElement;
   let root: Root;
   let health: HealthStatus;
-  const render = async () => { await act(async () => root.render(<AnnouncementWell health={health} />)); };
+  let client: QueryClient;
+  const render = async () => { await act(async () => root.render(<QueryClientProvider client={client}><AnnouncementWell health={health} /></QueryClientProvider>)); };
   const visible = () => Boolean(container.querySelector('[aria-label="Paperclip announcements"]'));
   beforeEach(() => {
     Object.assign(state, { userId: "alice", settled: true, companyId: "company", loading: false, onboardingOpen: false, toasts: [] });
     vi.clearAllMocks();
     health = { deploymentMode: "authenticated" } as HealthStatus;
+    // Onboarding is finished (no open first task); onboarding gating is covered in AnnouncementWell.onboarding.test.tsx.
+    client = new QueryClient({ defaultOptions: { queries: { retry: false, staleTime: Infinity } } });
+    client.setQueryData(["issues", "company", "onboarding-first-task"], []);
     container = document.createElement("div"); document.body.append(container); root = createRoot(container);
   });
   afterEach(async () => { await act(async () => root.unmount()); container.remove(); });
diff --git a/ui/src/components/AnnouncementWell.tsx b/ui/src/components/AnnouncementWell.tsx
index b71ce16f095..d5d263539a0 100644
--- a/ui/src/components/AnnouncementWell.tsx
+++ b/ui/src/components/AnnouncementWell.tsx
@@ -1,10 +1,14 @@
 import { useEffect, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { ONBOARDING_FIRST_TASK_ORIGIN_KIND } from "@paperclipai/shared";
 import { useAccountIdentity } from "@/api/companies-query";
 import type { HealthStatus } from "@/api/health";
+import { issuesApi } from "@/api/issues";
 import { useCompany } from "@/context/CompanyContext";
 import { useDialogState } from "@/context/DialogContext";
 import { useOptionalToastActions, useOptionalToastState } from "@/context/ToastContext";
 import { useAnnouncement } from "@/hooks/useAnnouncement";
+import { queryKeys } from "@/lib/queryKeys";
 import { AnnouncementCard } from "./AnnouncementCard";
 
 // Includes the command palette, sheets and dialogs created outside DialogContext.
@@ -22,16 +26,36 @@ function useModalOpen(enabled: boolean) {
   return open;
 }
 
+const FINISHED_ONBOARDING_STATUSES = new Set(["done", "cancelled"]);
+
+/**
+ * A new user's first session is the onboarding first task. Announcements wait
+ * until that task is finished so they cannot cover its questions. Unknown
+ * state (loading or a failed read) keeps the optional card hidden.
+ */
+function useOnboardingInProgress(companyId: string | null) {
+  const query = useQuery({
+    queryKey: queryKeys.issues.onboardingFirstTask(companyId ?? "__none__"),
+    queryFn: ({ signal }) => issuesApi.list(companyId!, { originKind: ONBOARDING_FIRST_TASK_ORIGIN_KIND, limit: 1 }, { signal }),
+    enabled: Boolean(companyId),
+    staleTime: 60_000,
+  });
+  if (!companyId) return false;
+  if (!query.isSuccess) return true;
+  return query.data.some((issue) => issue.originKind === ONBOARDING_FIRST_TASK_ORIGIN_KIND && !FINISHED_ONBOARDING_STATUSES.has(issue.status));
+}
+
 export function AnnouncementWell({ health }: { health?: HealthStatus }) {
   const { userId: accountId, settled } = useAccountIdentity();
   const { selectedCompanyId, loading } = useCompany();
   const { onboardingOpen } = useDialogState();
   const toastActions = useOptionalToastActions();
   const toasts = useOptionalToastState();
+  const onboardingInProgress = useOnboardingInProgress(selectedCompanyId);
   const userId = health?.deploymentMode === "local_trusted" ? "local-board" : (settled ? accountId : null);
   const { announcement, dismiss } = useAnnouncement({
     userId, companyId: selectedCompanyId,
-    enabled: Boolean(userId && !loading && selectedCompanyId && !onboardingOpen),
+    enabled: Boolean(userId && !loading && selectedCompanyId && !onboardingOpen && !onboardingInProgress),
     onSaveFailure: (savedLocally) => toastActions?.pushToast({
       title: savedLocally ? "Dismissed in this browser" : "Dismissed for this visit",
       body: "Couldn’t save across devices. We’ll retry when you reconnect or return.",
diff --git a/ui/src/lib/queryKeys.ts b/ui/src/lib/queryKeys.ts
index 3c88ecfec28..f13aae268f5 100644
--- a/ui/src/lib/queryKeys.ts
+++ b/ui/src/lib/queryKeys.ts
@@ -311,6 +311,8 @@ export const queryKeys = {
     recoveryActions: (id: string, actionId: string | null, runId: string | null) =>
       ["issues", id, "recovery-actions", actionId, runId] as const,
     list: (companyId: string) => ["issues", companyId] as const,
+    onboardingFirstTask: (companyId: string) =>
+      ["issues", companyId, "onboarding-first-task"] as const,
     mentionPool: (companyId: string) =>
       ["issues", companyId, "mention-pool"] as const,
     search: (