@shipfox/client-projects 24.0.0 → 26.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/client-projects",
   "license": "MIT",
-  "version": "24.0.0",
+  "version": "26.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -28,16 +28,16 @@
     "@swc/helpers": "^0.5.17",
     "@tanstack/react-form": "^1.32.0",
     "@shipfox/api-common-dto": "15.0.0",
-    "@shipfox/api-definitions-dto": "15.0.0",
-    "@shipfox/api-integration-core-dto": "15.0.0",
+    "@shipfox/api-definitions-dto": "16.1.0",
+    "@shipfox/api-integration-core-dto": "16.0.0",
     "@shipfox/api-projects-dto": "15.0.0",
-    "@shipfox/client-agent": "24.0.0",
+    "@shipfox/client-agent": "26.0.0",
     "@shipfox/client-api": "6.0.1",
-    "@shipfox/client-auth": "24.0.0",
-    "@shipfox/client-integrations": "24.0.0",
-    "@shipfox/client-shell": "24.0.0",
-    "@shipfox/client-ui": "24.0.0",
-    "@shipfox/react-ui": "2.2.0"
+    "@shipfox/client-auth": "26.0.0",
+    "@shipfox/client-integrations": "26.0.0",
+    "@shipfox/client-ui": "26.0.0",
+    "@shipfox/react-ui": "2.3.0",
+    "@shipfox/client-shell": "26.0.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.101.0",

package/src/hooks/api/projects.test.ts

@@ -4,9 +4,11 @@ import {
   createProject,
   isProjectSlugAvailable,
   listProjects,
+  projectExistenceQueryOptions,
   projectSlugQueryOptions,
   projectsInfiniteQueryOptions,
   projectsQueryKeys,
+  readWorkspaceHasNoProject,
   resolveProjectSlug,
   updateProject,
 } from './projects.js';
@@ -46,6 +48,123 @@ describe('listProjects', () => {
   });
 });
 
+describe('readWorkspaceHasNoProject', () => {
+  const WORKSPACE_ID = '11111111-1111-4111-8111-111111111111';
+
+  beforeEach(() => {
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});
+  });
+
+  test('returns true when the fresh existence read returns an empty list', async () => {
+    configureApiClient({
+      fetchImpl: vi.fn().mockResolvedValue(jsonResponse({projects: [], next_cursor: null})),
+    });
+
+    await expect(
+      readWorkspaceHasNoProject({queryClient: new QueryClient(), workspaceId: WORKSPACE_ID}),
+    ).resolves.toBe(true);
+  });
+
+  test('returns false when the fresh existence read returns a project', async () => {
+    configureApiClient({
+      fetchImpl: vi.fn().mockResolvedValue(
+        jsonResponse({
+          projects: [
+            {
+              id: '44444444-4444-4444-8444-444444444444',
+              workspace_id: WORKSPACE_ID,
+              name: 'Platform',
+              slug: 'platform',
+              source: {
+                connection_id: '33333333-3333-4333-8333-333333333333',
+                external_repository_id: 'platform',
+              },
+              created_at: '2026-05-07T01:00:00.000Z',
+              updated_at: '2026-05-07T01:00:00.000Z',
+            },
+          ],
+          next_cursor: null,
+        }),
+      ),
+    });
+
+    await expect(
+      readWorkspaceHasNoProject({queryClient: new QueryClient(), workspaceId: WORKSPACE_ID}),
+    ).resolves.toBe(false);
+  });
+
+  test('falls back to a cached empty list when the fresh read fails', async () => {
+    configureApiClient({
+      fetchImpl: vi
+        .fn()
+        .mockResolvedValue(jsonResponse({message: 'upstream unavailable'}, {status: 500})),
+    });
+    const queryClient = new QueryClient();
+    queryClient.setQueryData(projectExistenceQueryOptions(WORKSPACE_ID).queryKey, {
+      projects: [],
+      nextCursor: null,
+    });
+
+    await expect(readWorkspaceHasNoProject({queryClient, workspaceId: WORKSPACE_ID})).resolves.toBe(
+      true,
+    );
+  });
+
+  test('skips the fresh read when a cached non-empty list rules out the first-project path', async () => {
+    const fetchImpl = vi.fn().mockRejectedValue(new Error('unexpected fetch'));
+    configureApiClient({fetchImpl});
+    const queryClient = new QueryClient();
+    queryClient.setQueryData(projectExistenceQueryOptions(WORKSPACE_ID).queryKey, {
+      projects: [
+        {
+          id: '55555555-5555-4555-8555-555555555555',
+          workspaceId: WORKSPACE_ID,
+          name: 'Platform',
+          slug: 'platform',
+          source: {connectionId: 'c', externalRepositoryId: 'platform'},
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+      ],
+      nextCursor: null,
+    });
+
+    await expect(readWorkspaceHasNoProject({queryClient, workspaceId: WORKSPACE_ID})).resolves.toBe(
+      false,
+    );
+    // The landing is already decided, so no existence request is issued and no
+    // failure is reported for an established workspace.
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  test('returns false when the fresh read fails without any cache', async () => {
+    configureApiClient({
+      fetchImpl: vi
+        .fn()
+        .mockResolvedValue(jsonResponse({message: 'upstream unavailable'}, {status: 500})),
+    });
+
+    await expect(
+      readWorkspaceHasNoProject({queryClient: new QueryClient(), workspaceId: WORKSPACE_ID}),
+    ).resolves.toBe(false);
+  });
+
+  test('reports the failed fresh read to the error-reporting pipeline', async () => {
+    const reportErrorSpy = vi.fn();
+    vi.stubGlobal('reportError', reportErrorSpy);
+    configureApiClient({
+      fetchImpl: vi
+        .fn()
+        .mockResolvedValue(jsonResponse({message: 'upstream unavailable'}, {status: 500})),
+    });
+
+    await readWorkspaceHasNoProject({queryClient: new QueryClient(), workspaceId: WORKSPACE_ID});
+
+    expect(reportErrorSpy).toHaveBeenCalledOnce();
+    vi.unstubAllGlobals();
+  });
+});
+
 describe('createProject', () => {
   beforeEach(() => {
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});

package/src/hooks/api/projects.ts

@@ -305,6 +305,52 @@ export function projectExistenceQueryOptions(
   });
 }
 
+export async function readWorkspaceHasNoProject({
+  queryClient,
+  workspaceId,
+}: {
+  queryClient: QueryClient;
+  workspaceId: string;
+}): Promise<boolean> {
+  const options = projectExistenceQueryOptions(workspaceId);
+  // A cached non-empty list already rules out the first-project landing, so
+  // skip the fresh read entirely: the snapshot only steers navigation for the
+  // empty-workspace case, and a failed fresh read here would otherwise report
+  // a global error on every create in an established workspace without
+  // changing the landing.
+  const cached = queryClient.getQueryData<ProjectList>(options.queryKey);
+  if (cached !== undefined && cached.projects.length > 0) return false;
+  try {
+    // The landing decision must not trust fresh-but-stale existence data
+    // (e.g. a project created in another tab inside the 30s staleTime window),
+    // so force a fresh read for this check. The snapshot also runs without
+    // retry so a slow or failing existence endpoint cannot stall the submit
+    // handler on the app-default retry backoff; the catch falls back to cache.
+    const data = await queryClient.fetchQuery({...options, staleTime: 0, retry: false});
+    return data.projects.length === 0;
+  } catch (error) {
+    reportExistenceReadFailure(error);
+    const fallback = queryClient.getQueryData<ProjectList>(options.queryKey);
+    if (fallback !== undefined) return fallback.projects.length === 0;
+    // Unknown existence keeps the existing project navigation.
+    return false;
+  }
+}
+
+/**
+ * The existence snapshot is a best-effort pre-flight read: a failure must not
+ * block project creation, but it still reaches the global error-reporting
+ * pipeline so a degrading existence endpoint does not silently misroute the
+ * first-project landing.
+ */
+function reportExistenceReadFailure(error: unknown): void {
+  globalThis.reportError?.(
+    new Error('Failed to read workspace project existence for the first-project landing.', {
+      cause: error,
+    }),
+  );
+}
+
 export function projectQueryOptions(projectId: string | undefined): ProjectDetailQueryOptions {
   return queryOptions({
     queryKey: projectId

package/src/pages/create-project-page.test.tsx

@@ -2,7 +2,7 @@ import {configureApiClient} from '@shipfox/client-api';
 import {QueryClient} from '@tanstack/react-query';
 import {fireEvent, screen, waitFor, within} from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import {projectsQueryKeys} from '#hooks/api/projects.js';
+import {projectExistenceQueryOptions, projectsQueryKeys} from '#hooks/api/projects.js';
 import {
   jsonResponse,
   PROJECT_TEST_WID,
@@ -22,7 +22,7 @@ describe('CreateProjectPage', () => {
     window.sessionStorage.clear();
   });
 
-  test('with a single connection: pre-selects, renders repos, creates a project', async () => {
+  test('with a single connection: pre-selects, renders repos, and lands the first project on the workspace home', async () => {
     let createProjectBody: unknown;
     const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
       const request = input as Request;
@@ -32,6 +32,22 @@ describe('CreateProjectPage', () => {
       if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
         return jsonResponse({repositories: [repositoryDto()], next_cursor: null});
       }
+      if (request.url.includes('/projects?')) {
+        const url = new URL(request.url);
+        // The pre-create existence snapshot (limit=1) sees an empty workspace;
+        // the home list (limit=50) sees the created project, so the home does
+        // not fall back to the pre-create empty state.
+        if (url.searchParams.get('search')) {
+          return jsonResponse({projects: [], next_cursor: null});
+        }
+        if (url.searchParams.get('limit') === '1') {
+          return jsonResponse({projects: [], next_cursor: null});
+        }
+        return jsonResponse({
+          projects: [projectDto({id: '44444444-4444-4444-8444-444444444444'})],
+          next_cursor: null,
+        });
+      }
       if (request.url.endsWith('/projects') && request.method === 'POST') {
         createProjectBody = await request.json();
         return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
@@ -76,7 +92,13 @@ describe('CreateProjectPage', () => {
     expect(screen.getByText('/w/acme/p/launchpad')).toBeInTheDocument();
     fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
 
-    expect(await screen.findByRole('heading', {name: 'Runs'})).toBeInTheDocument();
+    // The first project lands on the workspace home, where the Get-started
+    // panel is the first panel, the just-created project is listed instead of
+    // the pre-create empty state, and the project detail is not shown.
+    expect(await screen.findByRole('searchbox', {name: 'Search projects'})).toBeInTheDocument();
+    expect(await screen.findByText('Project Detail')).toBeInTheDocument();
+    expect(screen.queryByText('Create your first project')).not.toBeInTheDocument();
+    expect(screen.queryByRole('heading', {name: 'Runs'})).not.toBeInTheDocument();
     expect(createProjectBody).toEqual({
       workspace_id: PROJECT_TEST_WID,
       name: 'Launch Pad',
@@ -88,6 +110,56 @@ describe('CreateProjectPage', () => {
     });
   }, 10_000);
 
+  test('does not double-submit while the existence snapshot is in flight', async () => {
+    let releaseExistenceRead: (() => void) | undefined;
+    const existenceReadGate = new Promise<void>((resolve) => {
+      releaseExistenceRead = resolve;
+    });
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return jsonResponse({connections: [connectionDto()]});
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return jsonResponse({repositories: [repositoryDto()], next_cursor: null});
+      }
+      if (request.url.includes('/projects?')) {
+        const url = new URL(request.url);
+        if (url.searchParams.get('limit') === '1') {
+          await existenceReadGate;
+          return jsonResponse({projects: [], next_cursor: null});
+        }
+        return jsonResponse({
+          projects: [projectDto({id: '44444444-4444-4444-8444-444444444444'})],
+          next_cursor: null,
+        });
+      }
+      if (request.url.endsWith('/projects') && request.method === 'POST') {
+        return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+      }
+      return jsonResponse({});
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/w/${PROJECT_TEST_WSLUG}/projects/new`, <CreateProjectPage />);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+
+    const createButton = screen.getByRole('button', {name: 'Create project'});
+    fireEvent.click(createButton);
+    fireEvent.click(createButton);
+
+    // The button stays disabled while the existence snapshot runs, so a second
+    // click cannot start a duplicate create.
+    await waitFor(() =>
+      expect(screen.getByRole('button', {name: 'Create project'})).toBeDisabled(),
+    );
+    releaseExistenceRead?.();
+
+    // Exactly one POST and a deterministic landing on the workspace home.
+    expect(await screen.findByRole('searchbox', {name: 'Search projects'})).toBeInTheDocument();
+    expect(projectPostCount(fetchImpl)).toBe(1);
+  }, 10_000);
+
   test('does not render an empty source panel when connections fail to load', async () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       const request = input as Request;
@@ -334,6 +406,56 @@ describe('CreateProjectPage', () => {
     expect(projectPostCount(fetchImpl)).toBe(0);
   });
 
+  test('with an existing project: keeps navigating to the created project', async () => {
+    let createProjectBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      const request = input as Request;
+      if (request.url.includes('/integration-connections?')) {
+        return jsonResponse({connections: [connectionDto()]});
+      }
+      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
+        return jsonResponse({repositories: [repositoryDto()], next_cursor: null});
+      }
+      if (request.url.endsWith('/projects') && request.method === 'POST') {
+        createProjectBody = await request.json();
+        return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+      }
+      return jsonResponse(projectDto({id: '44444444-4444-4444-8444-444444444444'}));
+    });
+    configureApiClient({fetchImpl});
+    const queryClient = new QueryClient({defaultOptions: {queries: {retry: false}}});
+    queryClient.setQueryData(projectExistenceQueryOptions(PROJECT_TEST_WID).queryKey, {
+      projects: [
+        {
+          id: '55555555-5555-4555-8555-555555555555',
+          workspaceId: PROJECT_TEST_WID,
+          name: 'Platform',
+          slug: 'platform',
+          source: {connectionId: CONNECTION_ID, externalRepositoryId: 'platform'},
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+      ],
+      nextCursor: null,
+    });
+
+    renderProjectPage(`/w/${PROJECT_TEST_WSLUG}/projects/new`, <CreateProjectPage />, queryClient);
+    expect((await screen.findAllByText('gitea-owner/platform')).length).toBeGreaterThan(0);
+    fireEvent.click(screen.getByRole('button', {name: 'Create project'}));
+
+    // A workspace that already has a project keeps landing on the project.
+    expect(await screen.findByRole('heading', {name: 'Runs'})).toBeInTheDocument();
+    expect(createProjectBody).toEqual({
+      workspace_id: PROJECT_TEST_WID,
+      name: 'Platform',
+      slug: 'platform',
+      source: {
+        connection_id: CONNECTION_ID,
+        external_repository_id: 'platform',
+      },
+    });
+  }, 10_000);
+
   test('with a single connection: shows workspace-scoped "Add another integration" link', async () => {
     configureApiClient({
       fetchImpl: vi.fn((input: RequestInfo | URL) => {
@@ -355,33 +477,6 @@ describe('CreateProjectPage', () => {
     expect(link).toHaveAttribute('href', `/w/${PROJECT_TEST_WSLUG}/integrations`);
   });
 
-  test('shows the model provider reminder on project creation when no provider is configured', async () => {
-    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
-      const request = input as Request;
-      if (request.url.endsWith('/agent/model-providers')) {
-        return Promise.resolve(
-          jsonResponse({configs: [], default_provider_id: null, default_harness_id: null}),
-        );
-      }
-      if (request.url.includes('/integration-connections?')) {
-        return Promise.resolve(jsonResponse({connections: [connectionDto()]}));
-      }
-      if (request.url.includes(`/integration-connections/${CONNECTION_ID}/repositories`)) {
-        return Promise.resolve(jsonResponse({repositories: [repositoryDto()], next_cursor: null}));
-      }
-      return Promise.resolve(jsonResponse({}));
-    });
-    configureApiClient({fetchImpl});
-
-    renderProjectPage(`/w/${PROJECT_TEST_WSLUG}/projects/new`, <CreateProjectPage />);
-
-    expect(await screen.findByText('Finish setting up a model provider')).toBeInTheDocument();
-    expect(screen.getByRole('link', {name: 'Agents'})).toHaveAttribute(
-      'href',
-      `/w/${PROJECT_TEST_WSLUG}/settings/agents`,
-    );
-  });
-
   test('navigates to the existing project for duplicate recovery', async () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       const request = input as Request;

package/src/pages/create-project-page.tsx

@@ -19,12 +19,18 @@ import {Panel, PanelActions, PanelBody, PanelHeader, PanelTitle} from '@shipfox/
 import {toast} from '@shipfox/react-ui/toast';
 import {Header, Text} from '@shipfox/react-ui/typography';
 import {useForm} from '@tanstack/react-form';
+import {type InfiniteData, useQueryClient} from '@tanstack/react-query';
 import {Link, Navigate, useNavigate} from '@tanstack/react-router';
 import {useEffect, useRef, useState} from 'react';
-import {ModelProviderReminderBanner} from '#components/model-provider-reminder-banner.js';
-import {type CreateProjectCommand, projectNameFromRepository} from '#core/project.js';
+import {
+  type CreateProjectCommand,
+  type ProjectList,
+  projectNameFromRepository,
+} from '#core/project.js';
 import {
   getProject,
+  projectsInfiniteQueryOptions,
+  readWorkspaceHasNoProject,
   useCreateProjectMutation,
   useProjectSlugAvailability,
 } from '#hooks/api/projects.js';
@@ -37,8 +43,13 @@ function isSlugValid(value: string): boolean {
 export function CreateProjectPage() {
   const workspace = useMaybeActiveWorkspace();
   const navigate = useNavigate();
+  const queryClient = useQueryClient();
   const createProject = useCreateProjectMutation();
   const errorRef = useRef<HTMLDivElement>(null);
+  // The submit flow awaits an existence snapshot before the create mutation, so
+  // the pending state must cover the whole handler, not just the mutation.
+  const submittingRef = useRef(false);
+  const [submitting, setSubmitting] = useState(false);
 
   const connectionsQuery = useSourceConnectionsQuery(workspace?.id);
   const connections = connectionsQuery.data ?? [];
@@ -150,8 +161,17 @@ export function CreateProjectPage() {
       errorRef.current?.focus();
       return;
     }
+    if (submittingRef.current) return;
+    submittingRef.current = true;
+    setSubmitting(true);
 
     try {
+      // Snapshot project existence before the mutation: after a successful
+      // create the workspace has one project and "first" is already false.
+      const wasFirstProject = await readWorkspaceHasNoProject({
+        queryClient,
+        workspaceId: workspace.id,
+      });
       const command: CreateProjectCommand = {
         workspaceId: workspace.id,
         name: projectName,
@@ -163,6 +183,35 @@ export function CreateProjectPage() {
       };
       const project = await createProject.mutateAsync(command);
       toast.success('Project created.');
+      if (wasFirstProject) {
+        // The setup checklist panel is the first thing on the home, so the
+        // first project lands where the Get-started guide lives. Seed the
+        // workspace list so the home does not re-render the pre-create empty
+        // state, then fetch the authoritative list: the seeded entry has no
+        // queryFn of its own (no observer mounted it), so refetching it would
+        // fail and a project created concurrently (another tab, import, or
+        // API) would stay hidden for the stale window. Fetching with
+        // staleTime: 0 forces a fresh read that replaces the seed; a failed
+        // fetch is swallowed so the seeded project remains the fallback and
+        // the home never shows a stale empty state.
+        const listQueryKey = projectsInfiniteQueryOptions(workspace.id).queryKey;
+        queryClient.setQueryData<InfiniteData<ProjectList, string | undefined>>(listQueryKey, {
+          pages: [{projects: [project], nextCursor: null}],
+          pageParams: [undefined],
+        });
+        await queryClient
+          .fetchInfiniteQuery({
+            ...projectsInfiniteQueryOptions(workspace.id),
+            staleTime: 0,
+            retry: false,
+          })
+          .catch(() => undefined);
+        await navigate({
+          to: '/w/$workspaceSlug',
+          params: {workspaceSlug: workspace.slug},
+        });
+        return;
+      }
       await navigate({
         to: '/w/$workspaceSlug/p/$projectSlug',
         params: {workspaceSlug: workspace.slug, projectSlug: project.slug},
@@ -191,6 +240,9 @@ export function CreateProjectPage() {
       }
       setFormError(`${copy.title}: ${copy.message}`);
       requestAnimationFrame(() => errorRef.current?.focus());
+    } finally {
+      submittingRef.current = false;
+      setSubmitting(false);
     }
   }
 
@@ -205,8 +257,6 @@ export function CreateProjectPage() {
         Create project
       </Header>
 
-      <ModelProviderReminderBanner workspaceId={workspace.id} />
-
       {connectionsQuery.isError ? (
         <Callout role="alert" type="error">
           <div className="flex w-full flex-wrap items-center justify-between gap-cluster">
@@ -399,7 +449,7 @@ export function CreateProjectPage() {
               <Button
                 type="submit"
                 iconRight="chevronRight"
-                isLoading={createProject.isPending}
+                isLoading={submitting}
                 disabled={!selectedConnection || !selectedRepository}
                 className="w-full"
               >

package/src/pages/projects-hub-page.test.tsx

@@ -25,7 +25,6 @@ describe('ProjectsHubPage', () => {
     configureApiClient({
       fetchImpl: createHubFetch({
         projects: jsonResponse({projects: [], next_cursor: null}),
-        modelProviders: jsonResponse(modelProviderConfigsDto()),
       }),
     });
 
@@ -46,13 +45,16 @@ describe('ProjectsHubPage', () => {
     configureApiClient({
       fetchImpl: createHubFetch({
         projects: jsonResponse({projects: [], next_cursor: null}),
-        modelProviders: jsonResponse(modelProviderConfigsDto()),
       }),
     });
 
     renderProjectPage(`/w/${PROJECT_TEST_WSLUG}`, <ProjectsHubPage />);
 
     expect(await screen.findByText('Create your first project')).toBeInTheDocument();
+    // Without the slot, the hub renders no checklist panel above the projects.
+    expect(
+      screen.queryByRole('region', {name: 'Workspace setup checklist'}),
+    ).not.toBeInTheDocument();
     const projectsRegion = screen.getByRole('region', {name: 'Projects'});
     expect(projectsRegion.querySelectorAll('[data-slot="panel"]')).toHaveLength(1);
     const panelHeader = projectsRegion.querySelector<HTMLElement>('[data-slot="panel-header"]');
@@ -74,50 +76,9 @@ describe('ProjectsHubPage', () => {
     ).toBe(WORKSPACE_PROJECTS_NEW_HREF);
   });
 
-  test('shows and dismisses the model provider reminder when no provider is configured', async () => {
-    const fetchImpl = createHubFetch({
-      projects: jsonResponse({projects: [], next_cursor: null}),
-      modelProviders: jsonResponse({
-        configs: [],
-        default_provider_id: null,
-        default_harness_id: null,
-      }),
-    });
-    configureApiClient({fetchImpl});
-
-    renderProjectPage(`/w/${PROJECT_TEST_WSLUG}`, <ProjectsHubPage />);
-
-    expect(await screen.findByText('Finish setting up a model provider')).toBeInTheDocument();
-    expect(screen.getByRole('link', {name: 'Agents'})).toHaveAttribute(
-      'href',
-      `/w/${PROJECT_TEST_WSLUG}/settings/agents`,
-    );
-    fireEvent.click(screen.getByRole('button', {name: 'Close'}));
-
-    await waitFor(() => {
-      expect(screen.queryByText('Finish setting up a model provider')).not.toBeInTheDocument();
-    });
-  });
-
-  test('hides the model provider reminder when a provider is configured', async () => {
-    const fetchImpl = createHubFetch({
-      projects: jsonResponse({projects: [], next_cursor: null}),
-      modelProviders: jsonResponse(modelProviderConfigsDto()),
-    });
-    configureApiClient({fetchImpl});
-
-    renderProjectPage(`/w/${PROJECT_TEST_WSLUG}`, <ProjectsHubPage />);
-
-    expect(await screen.findByText('Create your first project')).toBeInTheDocument();
-    expect(screen.queryByText('Finish setting up a model provider')).not.toBeInTheDocument();
-  });
-
   test('renders projects and loads the next cursor page', async () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       const url = new URL(requestInputUrl(input));
-      if (url.pathname.endsWith('/agent/model-providers')) {
-        return Promise.resolve(jsonResponse(modelProviderConfigsDto()));
-      }
       if (url.pathname === '/integration-connections') {
         return Promise.resolve(jsonResponse(connectionsDto()));
       }
@@ -188,9 +149,6 @@ describe('ProjectsHubPage', () => {
     let cursorRequests = 0;
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       const url = new URL(requestInputUrl(input));
-      if (url.pathname.endsWith('/agent/model-providers')) {
-        return Promise.resolve(jsonResponse(modelProviderConfigsDto()));
-      }
       if (url.pathname === '/integration-connections') {
         return Promise.resolve(jsonResponse(connectionsDto()));
       }
@@ -336,17 +294,12 @@ function createHubFetch({
     next_cursor: null,
   }),
   connections = jsonResponse(connectionsDto()),
-  modelProviders = jsonResponse(modelProviderConfigsDto()),
 }: {
   projects?: Response;
   connections?: Response;
-  modelProviders?: Response;
 } = {}) {
   return vi.fn((input: RequestInfo | URL) => {
     const url = new URL(requestInputUrl(input));
-    if (url.pathname.endsWith('/agent/model-providers')) {
-      return Promise.resolve(modelProviders.clone());
-    }
     if (url.pathname === '/integration-connections') {
       return Promise.resolve(connections.clone());
     }
@@ -387,22 +340,6 @@ function projectDto({
   };
 }
 
-function modelProviderConfigsDto() {
-  return {
-    configs: [
-      {
-        kind: 'builtin',
-        provider_id: 'anthropic',
-        default_model: null,
-        created_at: new Date().toISOString(),
-        updated_at: new Date().toISOString(),
-      },
-    ],
-    default_provider_id: 'anthropic',
-    default_harness_id: null,
-  };
-}
-
 function connectionsDto({
   lifecycleStatus = 'active',
   id = CONNECTION_ID,

package/src/pages/projects-hub-page.tsx

@@ -24,7 +24,6 @@ import {
 import {Skeleton} from '@shipfox/react-ui/skeleton';
 import {Text} from '@shipfox/react-ui/typography';
 import {Link, useNavigate} from '@tanstack/react-router';
-import {ModelProviderReminderBanner} from '#components/model-provider-reminder-banner.js';
 import type {Project} from '#core/project.js';
 import {useProjectsInfiniteQuery} from '#hooks/api/projects.js';
 
@@ -52,7 +51,6 @@ export function ProjectsHubPage({search = ''}: {search?: string}) {
   return (
     <div className="flex w-full flex-col gap-section">
       {WorkspaceSetupChecklist ? <WorkspaceSetupChecklist /> : null}
-      <ModelProviderReminderBanner workspaceId={workspace.id} />
 
       <section aria-label="Projects">
         <Panel>