@prenta/admin 1.14.0 → 1.16.0

package/src/__tests__/lib/seo-service-geo.test.ts

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { SeoGeoReport } from '../../lib/seo-service.js'
+
+/**
+ * Wire-level tests for the AI visibility (GEO measurement) service wrapper.
+ * The render test replaces `seo-service` wholesale, so the URL and the
+ * envelope handling are pinned here against a mocked `cmsApi`.
+ */
+const cmsApi = vi.fn()
+vi.mock('../../lib/api.js', () => ({ cmsApi: (...args: unknown[]) => cmsApi(...args) }))
+
+const svc = await import('../../lib/seo-service.js')
+
+const REPORT: SeoGeoReport = {
+  enabled: true,
+  window: { from: '2026-09-04', to: '2026-09-10', days: 7 },
+  firstSeenAt: null,
+  crawl: { total: { hits: 0, prevHits: null }, series: [], bots: [], topPaths: [], otherHits: 0 },
+  referrals: { total: { visits: 0, prevVisits: null }, engines: [], topPaths: [], otherVisits: 0 },
+}
+
+beforeEach(() => {
+  // Block body on purpose: `mockReset()` returns the mock, and vitest would
+  // run a returned function as after-test cleanup.
+  cmsApi.mockReset()
+})
+
+describe('fetchSeoGeo', () => {
+  it('GETs /seo/geo?days=N and unwraps the body', async () => {
+    cmsApi.mockResolvedValueOnce({ status: 200, data: REPORT })
+    await expect(svc.fetchSeoGeo(7)).resolves.toEqual(REPORT)
+    expect(cmsApi).toHaveBeenLastCalledWith('/seo/geo?days=7')
+
+    cmsApi.mockResolvedValueOnce({
+      status: 200,
+      data: { ...REPORT, window: { ...REPORT.window, days: 28 } },
+    })
+    const r = await svc.fetchSeoGeo(28)
+    expect(cmsApi).toHaveBeenLastCalledWith('/seo/geo?days=28')
+    expect(r.window.days).toBe(28)
+  })
+
+  it('throws on error envelopes', async () => {
+    cmsApi.mockResolvedValueOnce({ error: 'nope', status: 500 })
+    await expect(svc.fetchSeoGeo(28)).rejects.toThrow('nope')
+  })
+
+  it('rejects a malformed body instead of handing it to the UI', async () => {
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { enabled: 'yes' } })
+    await expect(svc.fetchSeoGeo(90)).rejects.toThrow('Unexpected AI visibility response')
+    cmsApi.mockResolvedValueOnce({ status: 200 })
+    await expect(svc.fetchSeoGeo(90)).rejects.toThrow('Unexpected AI visibility response')
+  })
+
+  it('rejects a body from an older server that lacks crawl.total', async () => {
+    const crawlWithoutTotal: Partial<SeoGeoReport['crawl']> = { ...REPORT.crawl }
+    delete crawlWithoutTotal.total
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { ...REPORT, crawl: crawlWithoutTotal } })
+    await expect(svc.fetchSeoGeo(28)).rejects.toThrow('Unexpected AI visibility response')
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { ...REPORT, crawl: undefined } })
+    await expect(svc.fetchSeoGeo(28)).rejects.toThrow('Unexpected AI visibility response')
+  })
+})
+
+// Mirrors `GET|PUT /seo/geo-settings` in `cms-core/src/api/routes/seo-geo.ts`:
+// GET answers `{ data: { enabled, retentionDays } }`; PUT takes a sparse
+// `{ enabled?, retentionDays? }` and answers `{ data: { ok: true } }` or a
+// 400 `{ error }` envelope.
+describe('fetchGeoSettings', () => {
+  it('GETs /seo/geo-settings and unwraps the body', async () => {
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { enabled: false, retentionDays: 30 } })
+    await expect(svc.fetchGeoSettings()).resolves.toEqual({ enabled: false, retentionDays: 30 })
+    expect(cmsApi).toHaveBeenCalledTimes(1)
+    expect(cmsApi).toHaveBeenLastCalledWith('/seo/geo-settings')
+  })
+
+  it('returns null on an error envelope (404 / GEO tables not migrated)', async () => {
+    cmsApi.mockResolvedValueOnce({ error: 'Not found', status: 404 })
+    await expect(svc.fetchGeoSettings()).resolves.toBeNull()
+    cmsApi.mockResolvedValueOnce({ error: 'Request failed (500)', status: 500 })
+    await expect(svc.fetchGeoSettings()).resolves.toBeNull()
+  })
+
+  it('returns null on a malformed body instead of handing it to the card', async () => {
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { enabled: 'yes', retentionDays: 90 } })
+    await expect(svc.fetchGeoSettings()).resolves.toBeNull()
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { enabled: true, retentionDays: '90' } })
+    await expect(svc.fetchGeoSettings()).resolves.toBeNull()
+    cmsApi.mockResolvedValueOnce({ status: 200 })
+    await expect(svc.fetchGeoSettings()).resolves.toBeNull()
+  })
+})
+
+describe('updateGeoSettings', () => {
+  it('PUTs the sparse patch as JSON and reports ok', async () => {
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { ok: true } })
+    await expect(svc.updateGeoSettings({ enabled: false })).resolves.toEqual({ ok: true })
+    expect(cmsApi).toHaveBeenLastCalledWith('/seo/geo-settings', {
+      method: 'PUT',
+      body: JSON.stringify({ enabled: false }),
+    })
+
+    cmsApi.mockResolvedValueOnce({ status: 200, data: { ok: true } })
+    await svc.updateGeoSettings({ retentionDays: 30 })
+    expect(cmsApi).toHaveBeenLastCalledWith('/seo/geo-settings', {
+      method: 'PUT',
+      body: JSON.stringify({ retentionDays: 30 }),
+    })
+  })
+
+  it('surfaces the validation error verbatim', async () => {
+    cmsApi.mockResolvedValueOnce({ error: 'retentionDays must be an integer', status: 400 })
+    await expect(svc.updateGeoSettings({ retentionDays: 1.5 })).resolves.toEqual({
+      ok: false,
+      error: 'retentionDays must be an integer',
+    })
+  })
+})

package/src/__tests__/lib/seo-service-proposals.test.ts

@@ -27,6 +27,35 @@ describe('proposal service helpers', () => {
     expect(cmsApi).toHaveBeenLastCalledWith('/seo/proposals')
   })
 
+  it('fetchSeoProposals fills in autopilot when an older core omits it', async () => {
+    cmsApi.mockResolvedValueOnce({
+      status: 200,
+      data: {
+        proposals: [],
+        counts: { issueFixes: 0, redirects: 0, stale: 0, eligibleForGeneration: 0 },
+        governance: { issueFixBulk: true, redirectBulk: false },
+      },
+    })
+    await expect(svc.fetchSeoProposals()).resolves.toEqual({
+      proposals: [],
+      counts: { issueFixes: 0, redirects: 0, stale: 0, eligibleForGeneration: 0 },
+      governance: { issueFixBulk: true, redirectBulk: false },
+      autopilot: { enabled: false, pausedReason: null, lastRunAt: null, appliedLast7d: 0 },
+    })
+    // A server that does send it wins over the fallback.
+    const autopilot = { enabled: true, pausedReason: null, lastRunAt: null, appliedLast7d: 3 }
+    cmsApi.mockResolvedValueOnce({
+      status: 200,
+      data: {
+        proposals: [],
+        counts: { issueFixes: 0, redirects: 0, stale: 0, eligibleForGeneration: 0 },
+        governance: { issueFixBulk: true, redirectBulk: false },
+        autopilot,
+      },
+    })
+    await expect(svc.fetchSeoProposals()).resolves.toMatchObject({ autopilot })
+  })
+
   it('generateSeoProposals POSTs confirm: true and returns the result or error', async () => {
     cmsApi.mockResolvedValueOnce({
       status: 200,

package/src/__tests__/router/seo-tab-for-path.test.ts

@@ -21,6 +21,11 @@ describe('seoTabForPath', () => {
     expect(seoTabForPath('/seo/proposals')).toBe('proposals')
   })
 
+  it('routes the AI visibility deep link (Technical → "View trends") to its tab', () => {
+    expect(SEO_DEEP_PATHS).toContain('/seo/ai-visibility')
+    expect(seoTabForPath('/seo/ai-visibility')).toBe('ai-visibility')
+  })
+
   it('returns null for non-SEO paths so they fall through', () => {
     expect(seoTabForPath('/dashboard')).toBeNull()
     expect(seoTabForPath('/media')).toBeNull()

package/src/__tests__/views/redirects-pane.render.test.tsx

@@ -36,9 +36,8 @@ const fetchRedirectRules = vi.fn(async () => RULES)
 const createRedirectRule = vi.fn(async (_p: unknown) => ({}))
 const updateRedirectRule = vi.fn(async (_id: string, _p: unknown) => ({}))
 const deleteRedirectRule = vi.fn(async (_id: string) => ({}))
-const generate404RecoverySuggestions = vi.fn(
-  async (): Promise<{ error?: string; autoApplied?: number; governanceBlocked?: string }> => ({}),
-)
+const generate404RecoverySuggestions = vi.fn(async (): Promise<{ error?: string }> => ({}))
+const saveRedirectRecoverySettings = vi.fn(async (_p: unknown): Promise<{ error?: string }> => ({}))
 
 vi.mock('../../lib/seo-service.js', () => ({
   fetchRedirectOverview: vi.fn(async () => ({
@@ -63,9 +62,9 @@ vi.mock('../../lib/seo-service.js', () => ({
   fetchRedirectRecoverySettings: vi.fn(async () => ({
     aiRerank: false,
     autoApply: false,
-    autoApplyMinConfidence: 0.85,
+    autoApplyMinConfidence: 85,
   })),
-  saveRedirectRecoverySettings: vi.fn(async () => ({})),
+  saveRedirectRecoverySettings: (p: unknown) => saveRedirectRecoverySettings(p),
 }))
 
 vi.mock('sonner', () => ({
@@ -79,6 +78,8 @@ beforeEach(() => {
   createRedirectRule.mockClear()
   updateRedirectRule.mockClear()
   deleteRedirectRule.mockClear()
+  generate404RecoverySuggestions.mockClear()
+  saveRedirectRecoverySettings.mockClear()
 })
 
 describe('Redirects inline editor pane', () => {
@@ -168,23 +169,42 @@ describe('Redirects inline editor pane', () => {
   })
 })
 
-describe('AI 404 recovery governance feedback', () => {
-  it('explains why auto-apply was skipped when governance blocked it', async () => {
-    generate404RecoverySuggestions.mockResolvedValueOnce({
-      autoApplied: 0,
-      governanceBlocked:
-        'The "404 Recovery suggestions" feature requires human approval before AI results are applied.',
-    })
+describe('404 recovery settings', () => {
+  it('points auto-apply at SEO Autopilot instead of exposing its own controls', async () => {
+    const onNavigate = vi.fn()
+    render(<RedirectsTab onNavigate={onNavigate} />)
+    await screen.findByRole('button', { name: '/old-path' })
+
+    // Task 8 moved the auto-apply policy into the autopilot; the card keeps
+    // AI re-ranking only and links to the Autopilot settings card.
+    expect(screen.getByLabelText('AI re-ranking')).toBeTruthy()
+    expect(screen.queryByLabelText(/Auto-apply high-confidence redirects/)).toBeNull()
+    expect(screen.queryByLabelText(/Auto-apply minimum confidence/)).toBeNull()
+    fireEvent.click(screen.getByRole('button', { name: 'SEO Autopilot' }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+    expect(screen.queryByRole('link')).toBeNull()
+  })
+
+  it('saves only the AI re-ranking flag', async () => {
+    render(<RedirectsTab />)
+    await screen.findByRole('button', { name: '/old-path' })
+    fireEvent.click(screen.getByLabelText('AI re-ranking'))
+    fireEvent.click(screen.getByRole('button', { name: 'Save settings' }))
+    await waitFor(() =>
+      expect(saveRedirectRecoverySettings).toHaveBeenCalledWith({ aiRerank: true }),
+    )
+  })
+
+  it('reports generation success without the retired auto-apply / governance messages', async () => {
+    generate404RecoverySuggestions.mockResolvedValueOnce({})
     const { toast } = await import('sonner')
 
     render(<RedirectsTab />)
     fireEvent.click(await screen.findByRole('button', { name: /Generate suggestions/ }))
 
-    // Generation succeeded — suggestions exist — but the operator is told the
-    // governance reason instead of silently seeing nothing auto-applied.
     await waitFor(() =>
-      expect(toast.info).toHaveBeenCalledWith(expect.stringContaining('requires human approval')),
+      expect(toast.success).toHaveBeenCalledWith('Generated 404 recovery suggestions.'),
     )
-    expect(toast.success).toHaveBeenCalledWith('Generated 404 recovery suggestions.')
+    expect(toast.info).not.toHaveBeenCalled()
   })
 })

package/src/__tests__/views/seo-ai-visibility.render.test.tsx

@@ -0,0 +1,279 @@
+// @vitest-environment happy-dom
+import type { ReactNode } from 'react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+import type { SeoGeoReport } from '../../lib/seo-service.js'
+
+function report(over: Partial<SeoGeoReport> = {}): SeoGeoReport {
+  return {
+    enabled: true,
+    window: { from: '2026-08-14', to: '2026-09-10', days: 28 },
+    firstSeenAt: '2026-08-01',
+    crawl: {
+      // Whole-window total from the server — includes the capped "other"
+      // bucket, so it is deliberately larger than the sum of `bots[].hits`.
+      total: { hits: 21, prevHits: 12 },
+      series: [
+        { date: '2026-09-09', hits: { GPTBot: 3, Googlebot: 5 } },
+        { date: '2026-09-10', hits: { GPTBot: 1 } },
+      ],
+      bots: [
+        {
+          bot: 'Googlebot',
+          category: 'search',
+          hits: 5,
+          prevHits: 4,
+          lastSeenAt: '2026-09-09',
+          policy: 'allowed',
+        },
+        {
+          bot: 'GPTBot',
+          category: 'training',
+          hits: 4,
+          prevHits: 8,
+          lastSeenAt: '2026-09-10',
+          policy: 'blocked_still_crawling',
+        },
+        {
+          bot: 'ClaudeBot',
+          category: 'training',
+          hits: 0,
+          prevHits: null,
+          lastSeenAt: null,
+          policy: 'blocked',
+        },
+      ],
+      topPaths: [
+        {
+          path: '/pricing',
+          hits: 6,
+          bots: ['GPTBot', 'Googlebot'],
+          entityId: 'doc-1',
+          entityTitle: 'Pricing',
+          collection: 'pages',
+        },
+        {
+          path: '/blog/launch',
+          hits: 4,
+          bots: ['GPTBot'],
+          entityId: 'doc-2',
+          entityTitle: 'Launch post',
+          collection: 'blog',
+        },
+        { path: '/legacy', hits: 3, bots: ['Googlebot'] },
+      ],
+      otherHits: 12,
+    },
+    referrals: {
+      total: { visits: 9, prevVisits: 3 },
+      engines: [
+        { engine: 'ChatGPT', visits: 7, prevVisits: 3 },
+        { engine: 'Perplexity', visits: 2, prevVisits: null },
+      ],
+      topPaths: [
+        {
+          path: '/pricing',
+          visits: 8,
+          engines: ['ChatGPT', 'Perplexity'],
+          entityId: 'doc-1',
+          entityTitle: 'Pricing',
+          collection: 'pages',
+        },
+        { path: '/blog/x', visits: 1, engines: ['ChatGPT'] },
+      ],
+      otherVisits: 4,
+    },
+    ...over,
+  }
+}
+
+const EMPTY_WINDOW: Pick<SeoGeoReport, 'crawl' | 'referrals'> = {
+  crawl: { total: { hits: 0, prevHits: null }, series: [], bots: [], topPaths: [], otherHits: 0 },
+  referrals: { total: { visits: 0, prevVisits: null }, engines: [], topPaths: [], otherVisits: 0 },
+}
+
+const fetchSeoGeo = vi.fn(async (_days: number): Promise<SeoGeoReport> => report())
+vi.mock('../../lib/seo-service.js', () => ({ fetchSeoGeo: (d: number) => fetchSeoGeo(d) }))
+// recharts needs layout; stub the chart so the table assertions drive the test.
+vi.mock('recharts', () => ({
+  ResponsiveContainer: ({ children }: { children: ReactNode }) => (
+    <div data-testid="chart">{children}</div>
+  ),
+  BarChart: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  Bar: () => null,
+  XAxis: () => null,
+  YAxis: () => null,
+  Tooltip: () => null,
+  Legend: () => null,
+  CartesianGrid: () => null,
+}))
+
+const { AiVisibilityTab } = await import('../../views/seo/AiVisibilityTab.js')
+
+beforeEach(() => {
+  fetchSeoGeo.mockReset()
+  fetchSeoGeo.mockImplementation(async () => report())
+})
+
+describe('AiVisibilityTab', () => {
+  it('renders bots with policy text, deltas, and top paths with editor links gated on entityId', async () => {
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    expect(fetchSeoGeo).toHaveBeenCalledWith(28)
+
+    const crawlers = screen.getByRole('table', { name: /crawlers/i })
+    expect(within(crawlers).getByText('Blocked — still crawling')).toBeTruthy()
+    expect(within(crawlers).getByText('Allowed')).toBeTruthy()
+    expect(within(crawlers).getByText('Blocked')).toBeTruthy()
+    expect(within(crawlers).getAllByText('AI training', { selector: 'td' })).toHaveLength(2)
+    expect(within(crawlers).getByText('Search', { selector: 'td' })).toBeTruthy()
+    // null prevHits (ClaudeBot) and null lastSeenAt both render as an em dash.
+    expect(within(crawlers).getAllByText('—').length).toBeGreaterThanOrEqual(2)
+    // +25% (5 vs 4) and -50% (4 vs 8).
+    expect(within(crawlers).getByText('+25%')).toBeTruthy()
+    expect(within(crawlers).getByText('-50%')).toBeTruthy()
+
+    // Headline crawl number comes from `crawl.total`, not from summing bots.
+    const crawlSummary = screen.getByRole('group', { name: /crawl summary/i })
+    expect(within(crawlSummary).getByText('21')).toBeTruthy()
+    expect(within(crawlSummary).getByText('+75%')).toBeTruthy()
+
+    expect(screen.getByTestId('chart')).toBeTruthy()
+
+    const cited = screen.getByRole('table', { name: /top cited pages/i })
+    fireEvent.click(within(cited).getByRole('button', { name: /open pricing in editor/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/pages/doc-1/edit')
+    expect(within(cited).queryByRole('button', { name: /open \/blog\/x/i })).toBeNull()
+    expect(within(cited).getByText('/blog/x')).toBeTruthy()
+
+    // Post-type collections route through the post editor, not the pages one.
+    const crawled = screen.getByRole('table', { name: /top crawled pages/i })
+    fireEvent.click(within(crawled).getByRole('button', { name: /open launch post in editor/i }))
+    expect(onNavigate).toHaveBeenLastCalledWith('/posts/blog/doc-2/edit')
+    expect(within(crawled).queryByRole('button', { name: /open \/legacy/i })).toBeNull()
+
+    expect(screen.getByText(/12 hits on paths beyond the daily cap/i)).toBeTruthy()
+    expect(screen.getByText(/4 visits on paths beyond the daily cap/i)).toBeTruthy()
+    expect(screen.getByText(/self-reported by your middleware/i)).toBeTruthy()
+  })
+
+  it('renders paths as plain text when there is no onNavigate, even with an entityId', async () => {
+    render(<AiVisibilityTab />)
+    const cited = await screen.findByRole('table', { name: /top cited pages/i })
+    expect(within(cited).queryByRole('button')).toBeNull()
+    expect(within(cited).getByText('/pricing')).toBeTruthy()
+  })
+
+  it('switching the window refetches', async () => {
+    render(<AiVisibilityTab />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    const group = screen.getByRole('group', { name: /^window$/i })
+    const seven = within(group).getByRole('button', { name: /7 days/i })
+    expect(seven.getAttribute('aria-pressed')).toBe('false')
+    expect(
+      within(group)
+        .getByRole('button', { name: /28 days/i })
+        .getAttribute('aria-pressed'),
+    ).toBe('true')
+    fireEvent.click(seven)
+    await waitFor(() => expect(fetchSeoGeo).toHaveBeenLastCalledWith(7))
+    expect(seven.getAttribute('aria-pressed')).toBe('true')
+  })
+
+  it('keeps the clicked window button focused and enabled while the refetch is in flight', async () => {
+    render(<AiVisibilityTab />)
+    await screen.findByRole('table', { name: /crawlers/i })
+    // Hold the second request open so we can inspect the loading state.
+    let release: (() => void) | undefined
+    fetchSeoGeo.mockImplementationOnce(
+      () =>
+        new Promise<SeoGeoReport>((resolve) => {
+          release = () => resolve(report())
+        }),
+    )
+    const seven = screen.getByRole('button', { name: /7 days/i })
+    seven.focus()
+    fireEvent.click(seven)
+    await waitFor(() => expect(fetchSeoGeo).toHaveBeenLastCalledWith(7))
+    expect((seven as HTMLButtonElement).disabled).toBe(false)
+    expect(document.activeElement).toBe(seven)
+    release?.()
+    await screen.findByRole('table', { name: /crawlers/i })
+  })
+
+  it('exposes the null-baseline dash to assistive tech, not only via title', async () => {
+    render(<AiVisibilityTab />)
+    const crawlers = await screen.findByRole('table', { name: /crawlers/i })
+    expect(within(crawlers).getAllByText('No full prior window yet').length).toBeGreaterThan(0)
+    expect(screen.getByText(/first seen/i)).toBeTruthy()
+    expect(screen.queryByText(/collecting since/i)).toBeNull()
+  })
+
+  it('shows the disabled state with a settings button (disabledReason: settings)', async () => {
+    fetchSeoGeo.mockResolvedValue(
+      report({ enabled: false, disabledReason: 'settings', firstSeenAt: null, ...EMPTY_WINDOW }),
+    )
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByText(/measurement is off/i)
+    // The header (window switch + Refresh) stays available in every state.
+    expect(screen.getByRole('button', { name: /refresh/i })).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: /open seo settings/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+
+  it('falls back to the settings copy when enabled:false carries no disabledReason (older core)', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ enabled: false, firstSeenAt: null, ...EMPTY_WINDOW }))
+    render(<AiVisibilityTab onNavigate={vi.fn()} />)
+    await screen.findByText(/measurement is off/i)
+    expect(screen.getByRole('button', { name: /open seo settings/i })).toBeTruthy()
+  })
+
+  it('shows the not-migrated state without a settings action (disabledReason: unavailable)', async () => {
+    fetchSeoGeo.mockResolvedValue(
+      report({ enabled: false, disabledReason: 'unavailable', firstSeenAt: null, ...EMPTY_WINDOW }),
+    )
+    render(<AiVisibilityTab onNavigate={vi.fn()} />)
+    await screen.findByText(/geo tables not migrated/i)
+    expect(screen.getByText(/prisma migrate deploy/i)).toBeTruthy()
+    expect(screen.getByText(/0018_geo_daily/i)).toBeTruthy()
+    expect(screen.queryByText(/measurement is off/i)).toBeNull()
+    expect(screen.queryByRole('button', { name: /open seo settings/i })).toBeNull()
+    expect(screen.getByRole('button', { name: /refresh/i })).toBeTruthy()
+  })
+
+  it('shows the not-reporting state with a middleware-snippet action when nothing has ever arrived', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ firstSeenAt: null, ...EMPTY_WINDOW }))
+    const onNavigate = vi.fn()
+    render(<AiVisibilityTab onNavigate={onNavigate} />)
+    await screen.findByText(/site middleware is not reporting yet/i)
+    expect(screen.queryByRole('table')).toBeNull()
+    fireEvent.click(screen.getByRole('button', { name: /show middleware snippet/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+
+  it('omits the middleware-snippet action when there is no navigator', async () => {
+    fetchSeoGeo.mockResolvedValue(report({ firstSeenAt: null, ...EMPTY_WINDOW }))
+    render(<AiVisibilityTab />)
+    await screen.findByText(/site middleware is not reporting yet/i)
+    expect(screen.queryByRole('button', { name: /show middleware snippet/i })).toBeNull()
+  })
+
+  it('shows an empty state when reporting but the window is empty', async () => {
+    fetchSeoGeo.mockResolvedValue(report(EMPTY_WINDOW))
+    render(<AiVisibilityTab />)
+    await screen.findByText(/no ai crawler or referral activity in this window/i)
+    expect(screen.queryByRole('table')).toBeNull()
+  })
+
+  it('shows an error state with retry', async () => {
+    fetchSeoGeo.mockRejectedValueOnce(new Error('boom'))
+    render(<AiVisibilityTab />)
+    const alert = await screen.findByRole('alert')
+    expect(within(alert).getByText('boom')).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: /retry/i }))
+    await screen.findByRole('table', { name: /crawlers/i })
+    expect(fetchSeoGeo).toHaveBeenCalledTimes(2)
+  })
+})