@prenta/admin 1.14.0 → 1.16.0

package/src/__tests__/views/seo-geo-settings-card.render.test.tsx

@@ -0,0 +1,253 @@
+// @vitest-environment happy-dom
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+
+type Settings = { enabled: boolean; retentionDays: number }
+type UpdateResult = { ok: boolean; error?: string }
+
+let current: Settings = { enabled: true, retentionDays: 90 }
+/** When set, the next PUT waits on this so a test can observe the in-flight state. */
+let putGate: Promise<void> | null = null
+
+function deferred(): { promise: Promise<void>; resolve: () => void } {
+  let resolve!: () => void
+  const promise = new Promise<void>((r) => {
+    resolve = r
+  })
+  return { promise, resolve }
+}
+
+async function defaultUpdate(patch: Partial<Settings>): Promise<UpdateResult> {
+  if (putGate) await putGate
+  current = { ...current, ...patch }
+  return { ok: true }
+}
+const fetchGeoSettings = vi.fn(async (): Promise<Settings | null> => ({ ...current }))
+const updateGeoSettings = vi.fn(defaultUpdate)
+vi.mock('../../lib/seo-service.js', () => ({
+  SEO_GEO_RETENTION: { min: 7, max: 365 },
+  fetchGeoSettings: () => fetchGeoSettings(),
+  updateGeoSettings: (p: Partial<Settings>) => updateGeoSettings(p),
+}))
+const toastSuccess = vi.fn()
+const toastError = vi.fn()
+vi.mock('sonner', () => ({
+  toast: {
+    success: (...a: unknown[]) => toastSuccess(...a),
+    error: (...a: unknown[]) => toastError(...a),
+    warning: vi.fn(),
+    info: vi.fn(),
+  },
+}))
+
+const { SeoGeoSettingsCard } = await import('../../views/settings/SeoGeoSettingsCard.js')
+
+const SWITCH = /record ai crawler and referral activity/i
+const RETENTION = /retention \(days\)/i
+
+beforeEach(() => {
+  current = { enabled: true, retentionDays: 90 }
+  putGate = null
+  fetchGeoSettings.mockClear()
+  fetchGeoSettings.mockImplementation(async () => ({ ...current }))
+  updateGeoSettings.mockClear()
+  updateGeoSettings.mockImplementation(defaultUpdate)
+  toastSuccess.mockClear()
+  toastError.mockClear()
+})
+
+describe('SeoGeoSettingsCard', () => {
+  it('renders the toggle, retention, and both middleware snippets', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const toggle = await screen.findByRole('switch', { name: SWITCH })
+    expect(toggle.getAttribute('aria-checked')).toBe('true')
+    expect((screen.getByLabelText(RETENTION) as HTMLInputElement).value).toBe('90')
+    expect(screen.getByText(/observeGeoTraffic\(request/)).toBeTruthy()
+    expect(screen.getByText(/createAstroRedirectMiddleware/)).toBeTruthy()
+    // Scrollable snippets are focusable and named so keyboard users can scroll them.
+    for (const name of ['Next.js middleware snippet', 'Astro middleware snippet']) {
+      const pre = screen.getByLabelText(name)
+      expect(pre.tagName).toBe('PRE')
+      expect(pre.getAttribute('tabindex')).toBe('0')
+    }
+    // The kill-switch consequences are spelled out in the card copy.
+    const card = screen.getByRole('region', { name: 'AI visibility' })
+    expect(card.textContent ?? '').toMatch(/drops incoming beacons/i)
+    expect(card.textContent ?? '').toMatch(/AI visibility tab/i)
+    // This card takes no `onNavigate`, so it must not link anywhere.
+    expect(card.querySelector('a')).toBeNull()
+  })
+
+  it('toggling PUTs { enabled: false }, reloads, and reflects the server state', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    fireEvent.click(await screen.findByRole('switch', { name: SWITCH }))
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ enabled: false }))
+    await waitFor(() => expect(fetchGeoSettings).toHaveBeenCalledTimes(2))
+    await waitFor(() =>
+      expect(screen.getByRole('switch', { name: SWITCH }).getAttribute('aria-checked')).toBe(
+        'false',
+      ),
+    )
+    expect(toastSuccess).toHaveBeenCalledWith('AI visibility measurement disabled')
+  })
+
+  it('marks the card busy while a save is in flight and keeps the toggle focused', async () => {
+    const gate = deferred()
+    putGate = gate.promise
+    render(<SeoGeoSettingsCard canEdit />)
+    const toggle = await screen.findByRole('switch', { name: SWITCH })
+    const card = screen.getByRole('region', { name: 'AI visibility' })
+    toggle.focus()
+    fireEvent.click(toggle)
+    await waitFor(() => expect(card.getAttribute('aria-busy')).toBe('true'))
+    expect((toggle as HTMLButtonElement).disabled).toBe(false)
+    expect(document.activeElement).toBe(toggle)
+    gate.resolve()
+    await waitFor(() => expect(card.getAttribute('aria-busy')).toBeNull())
+  })
+
+  it('surfaces a failed toggle PUT as a toast and keeps the previous state', async () => {
+    updateGeoSettings.mockResolvedValueOnce({ ok: false, error: 'enabled must be a boolean' })
+    render(<SeoGeoSettingsCard canEdit />)
+    fireEvent.click(await screen.findByRole('switch', { name: SWITCH }))
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('enabled must be a boolean'))
+    expect(screen.getByRole('switch', { name: SWITCH }).getAttribute('aria-checked')).toBe('true')
+    expect(toastSuccess).not.toHaveBeenCalled()
+    expect(fetchGeoSettings).toHaveBeenCalledTimes(1)
+  })
+
+  it('clamps retention to 7–365 and commits on blur', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '1000' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 365 }))
+    await waitFor(() => expect(input.value).toBe('365'))
+    expect(toastSuccess).toHaveBeenCalledWith('Retention set to 365 days')
+
+    fireEvent.change(input, { target: { value: '2' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenLastCalledWith({ retentionDays: 7 }))
+    await waitFor(() => expect(input.value).toBe('7'))
+  })
+
+  it('commits retention on Enter', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    // Enter commits by blurring the (focused) input, so the blur path is the
+    // single commit point and a following real blur cannot double-PUT.
+    input.focus()
+    fireEvent.change(input, { target: { value: '30' } })
+    fireEvent.keyDown(input, { key: 'Enter' })
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 30 }))
+    expect(updateGeoSettings).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not PUT when retention is blurred unchanged', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.blur(input)
+    fireEvent.change(input, { target: { value: '90' } })
+    fireEvent.blur(input)
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(input.value).toBe('90')
+  })
+
+  it('shows an inline error for a non-numeric retention instead of a toast or a PUT', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '' } })
+    fireEvent.blur(input)
+    const error = await screen.findByText(/whole number of days/i)
+    expect(input.getAttribute('aria-invalid')).toBe('true')
+    expect(input.getAttribute('aria-describedby') ?? '').toContain(error.id)
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(toastError).not.toHaveBeenCalled()
+    // Typing again clears the error; a valid commit then lands.
+    fireEvent.change(input, { target: { value: '14' } })
+    expect(input.getAttribute('aria-invalid')).toBeNull()
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 14 }))
+  })
+
+  it('rejects a fractional retention with the inline error and no PUT', async () => {
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '7.5' } })
+    fireEvent.blur(input)
+    await screen.findByText(/whole number of days/i)
+    expect(input.getAttribute('aria-invalid')).toBe('true')
+    expect(input.value).toBe('7.5')
+    expect(updateGeoSettings).not.toHaveBeenCalled()
+    expect(toastError).not.toHaveBeenCalled()
+  })
+
+  it('a failed second queued commit reverts to the first commit’s confirmed value', async () => {
+    // A: 90→30 is held in flight; B: →60 is blurred behind it and fails only
+    // after A's result has rendered. The revert must land on 30 (what the
+    // server holds), not the 90 that B's commit closed over.
+    const gateA = deferred()
+    const gateB = deferred()
+    updateGeoSettings.mockImplementation(async (patch) => {
+      if (updateGeoSettings.mock.calls.length === 1) {
+        await gateA.promise
+        current = { ...current, ...patch }
+        return { ok: true }
+      }
+      await gateB.promise
+      return { ok: false, error: 'nope' }
+    })
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '30' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 30 }))
+    fireEvent.change(input, { target: { value: '60' } })
+    fireEvent.blur(input)
+    expect(updateGeoSettings).toHaveBeenCalledTimes(1)
+
+    gateA.resolve()
+    await waitFor(() => expect(toastSuccess).toHaveBeenCalledWith('Retention set to 30 days'))
+    await waitFor(() => expect(input.value).toBe('30'))
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 60 }))
+
+    gateB.resolve()
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('nope'))
+    // Let the failed commit's revert (a microtask after the toast) render
+    // before asserting; a stale-closure revert would now show "90".
+    await new Promise((r) => setTimeout(r, 50))
+    expect(input.value).toBe('30')
+    expect(toastSuccess).toHaveBeenCalledTimes(1)
+  })
+
+  it('reverts retention to the last saved value when its PUT fails', async () => {
+    updateGeoSettings.mockResolvedValueOnce({ ok: false, error: 'nope' })
+    render(<SeoGeoSettingsCard canEdit />)
+    const input = (await screen.findByLabelText(RETENTION)) as HTMLInputElement
+    fireEvent.change(input, { target: { value: '1000' } })
+    fireEvent.blur(input)
+    await waitFor(() => expect(updateGeoSettings).toHaveBeenCalledWith({ retentionDays: 365 }))
+    await waitFor(() => expect(toastError).toHaveBeenCalledWith('nope'))
+    await waitFor(() => expect(input.value).toBe('90'))
+    expect(toastSuccess).not.toHaveBeenCalled()
+  })
+
+  it('disables controls without edit rights', async () => {
+    render(<SeoGeoSettingsCard canEdit={false} />)
+    const toggle = (await screen.findByRole('switch', { name: SWITCH })) as HTMLButtonElement
+    expect(toggle.disabled).toBe(true)
+    expect((screen.getByLabelText(RETENTION) as HTMLInputElement).disabled).toBe(true)
+    // Read-only users still see the setup snippets.
+    expect(screen.getByText(/observeGeoTraffic\(request/)).toBeTruthy()
+  })
+
+  it('shows an error state with Retry when settings fail to load', async () => {
+    fetchGeoSettings.mockResolvedValueOnce(null)
+    render(<SeoGeoSettingsCard canEdit />)
+    const retry = await screen.findByRole('button', { name: /retry/i })
+    expect(screen.getByRole('alert').textContent ?? '').toMatch(/AI visibility settings/i)
+    fireEvent.click(retry)
+    await screen.findByRole('switch', { name: SWITCH })
+    expect(fetchGeoSettings).toHaveBeenCalledTimes(2)
+  })
+})

package/src/__tests__/views/seo-proposals-tab.render.test.tsx

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { fireEvent, render, screen, waitFor } from '@testing-library/react'
 
 import type {
+  SeoAutoApplyList,
   SeoProposal,
   SeoProposalBulkApplyResult,
   SeoProposalsPayload,
@@ -57,11 +58,24 @@ function payload(over: Partial<SeoProposalsPayload> = {}): SeoProposalsPayload {
     ],
     counts: { issueFixes: 2, redirects: 1, stale: 0, eligibleForGeneration: 5 },
     governance: { issueFixBulk: true, redirectBulk: true },
+    autopilot: { enabled: false, pausedReason: null, lastRunAt: null, appliedLast7d: 0 },
     ...over,
   }
 }
 
 const fetchSeoProposals = vi.fn(async () => payload())
+const fetchAutopilotApplied = vi.fn(
+  async (_params: unknown): Promise<SeoAutoApplyList> => ({
+    docs: [],
+    total: 0,
+    page: 1,
+    pageSize: 20,
+    canRevert: false,
+  }),
+)
+const revertAutopilotChange = vi.fn(async (_id: string, _force?: boolean) => ({
+  ok: true as const,
+}))
 const generateSeoProposals = vi.fn(async () => ({
   result: { generated: 2, skipped: 0, failed: 0, remaining: 0, haltedReason: null },
 }))
@@ -79,6 +93,8 @@ vi.mock('../../lib/seo-service.js', () => ({
   bulkApplySeoProposals: (items: unknown) => bulkApplySeoProposals(items),
   dismissSeoIssueFix: (id: string) => dismissSeoIssueFix(id),
   dismissRedirectSuggestion: (id: string) => dismissRedirectSuggestion(id),
+  fetchAutopilotApplied: (params: unknown) => fetchAutopilotApplied(params),
+  revertAutopilotChange: (id: string, force?: boolean) => revertAutopilotChange(id, force),
 }))
 vi.mock('sonner', () => ({
   toast: { success: vi.fn(), error: vi.fn(), info: vi.fn(), loading: vi.fn() },
@@ -109,6 +125,8 @@ beforeEach(() => {
   bulkApplySeoProposals.mockClear()
   dismissSeoIssueFix.mockClear()
   dismissRedirectSuggestion.mockClear()
+  fetchAutopilotApplied.mockClear()
+  revertAutopilotChange.mockClear()
   vi.mocked(toast.success).mockClear()
   vi.mocked(toast.error).mockClear()
 })
@@ -361,6 +379,149 @@ describe('ProposalsTab', () => {
     )
   })
 
+  it('renders the applied-by-autopilot section under the proposals card', async () => {
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    expect(await screen.findByText('Applied by autopilot')).toBeTruthy()
+    await waitFor(() => expect(fetchAutopilotApplied).toHaveBeenCalledTimes(1))
+    expect(await screen.findByText('Autopilot has not applied anything yet')).toBeTruthy()
+  })
+
+  it('shows no autopilot chip while autopilot is disabled', async () => {
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    expect(screen.queryByRole('button', { name: /autopilot (on|paused)/i })).toBeNull()
+  })
+
+  it('shows an "Autopilot on" chip with the weekly count that opens SEO settings', async () => {
+    fetchSeoProposals.mockImplementationOnce(async () =>
+      payload({
+        autopilot: {
+          enabled: true,
+          pausedReason: null,
+          lastRunAt: '2026-09-07T03:00:00.000Z',
+          appliedLast7d: 4,
+        },
+      }),
+    )
+    const onNavigate = vi.fn()
+    render(<ProposalsTab planInfo={null} onNavigate={onNavigate} />)
+    await screen.findByText('Duplicate meta title')
+    const chip = screen.getByRole('button', { name: 'Autopilot on · 4 applied this week' })
+    fireEvent.click(chip)
+    expect(onNavigate).toHaveBeenCalledWith('/settings?tab=seo')
+  })
+
+  it('shows a paused chip with a short reason when autopilot is paused', async () => {
+    fetchSeoProposals.mockImplementationOnce(async () =>
+      payload({
+        autopilot: {
+          enabled: true,
+          pausedReason: 'outcome_regression',
+          lastRunAt: null,
+          appliedLast7d: 1,
+        },
+      }),
+    )
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    expect(
+      screen.getByRole('button', { name: 'Autopilot paused — traffic regression' }),
+    ).toBeTruthy()
+    expect(screen.queryByRole('button', { name: /applied this week/ })).toBeNull()
+  })
+
+  it.each([
+    ['owner_unavailable', 'Autopilot paused — owner unavailable'],
+    ['manual', 'Autopilot paused — paused by admin'],
+    ['some_future_reason', 'Autopilot paused — some_future_reason'],
+  ])('labels the %s pause reason as "%s"', async (pausedReason, name) => {
+    fetchSeoProposals.mockImplementationOnce(async () =>
+      payload({ autopilot: { enabled: true, pausedReason, lastRunAt: null, appliedLast7d: 0 } }),
+    )
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    expect(screen.getByRole('button', { name })).toBeTruthy()
+  })
+
+  it('shows no chip when autopilot was disabled while still paused', async () => {
+    // `PUT { enabled: false }` does not clear the pause; a disabled engine is
+    // simply off, not "paused".
+    fetchSeoProposals.mockImplementationOnce(async () =>
+      payload({
+        autopilot: { enabled: false, pausedReason: 'manual', lastRunAt: null, appliedLast7d: 0 },
+      }),
+    )
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    expect(screen.queryByRole('button', { name: /autopilot/i })).toBeNull()
+  })
+
+  it('shows no chip and does not throw when the payload predates autopilot', async () => {
+    fetchSeoProposals.mockImplementationOnce(async () => {
+      // A `@prenta/core` deployed before autopilot shipped omits the field entirely.
+      const legacy: Partial<SeoProposalsPayload> = payload()
+      delete legacy.autopilot
+      return legacy as SeoProposalsPayload
+    })
+    render(<ProposalsTab planInfo={null} />)
+    expect(await screen.findByText('Duplicate meta title')).toBeTruthy()
+    expect(screen.queryByRole('button', { name: /autopilot (on|paused)/i })).toBeNull()
+    expect(screen.getByRole('button', { name: 'Generate proposals (5 eligible)' })).toBeTruthy()
+  })
+
+  it('refreshes the applied section after a proposal is approved', async () => {
+    render(<ProposalsTab planInfo={null} />)
+    await screen.findByText('Duplicate meta title')
+    await waitFor(() => expect(fetchAutopilotApplied).toHaveBeenCalledTimes(1))
+    fireEvent.click(screen.getByRole('button', { name: 'Approve Duplicate meta title' }))
+    await waitFor(() => expect(bulkApplySeoProposals).toHaveBeenCalledTimes(1))
+    await waitFor(() => expect(fetchAutopilotApplied).toHaveBeenCalledTimes(2))
+  })
+
+  it('refetches the inbox and notifies the parent after an autopilot change is reverted', async () => {
+    fetchAutopilotApplied.mockImplementation(async () => ({
+      docs: [
+        {
+          id: 'la-1',
+          kind: 'issue-fix',
+          issueType: 'missing-meta-title',
+          entityId: 'd1',
+          collection: 'pages',
+          entityTitle: 'Pricing',
+          entityUrl: '/pricing',
+          path: '/pricing',
+          before: { metaTitle: null },
+          after: { metaTitle: 'Pricing for growing teams' },
+          gate: { source: 'ai', brandAlignment: 92, confidence: null, checks: {} },
+          status: 'applied',
+          outcome: 'pending',
+          outcomeMetrics: null,
+          appliedAt: new Date().toISOString(),
+          revertedAt: null,
+          revertReason: null,
+        },
+      ],
+      total: 1,
+      page: 1,
+      pageSize: 20,
+      canRevert: true,
+    }))
+    const onChanged = vi.fn()
+    render(<ProposalsTab planInfo={null} onChanged={onChanged} />)
+    await screen.findByText('Duplicate meta title')
+    fireEvent.click(await screen.findByRole('button', { name: 'Revert change to Pricing' }))
+    fireEvent.click(await screen.findByRole('button', { name: 'Revert change' }))
+    await waitFor(() => expect(revertAutopilotChange).toHaveBeenCalledWith('la-1', false))
+    // The revert reopened the issue server-side: the inbox and the SEO page must both refresh.
+    await waitFor(() => expect(fetchSeoProposals).toHaveBeenCalledTimes(2))
+    await waitFor(() => expect(onChanged).toHaveBeenCalledTimes(1))
+    // The ledger reloads itself once; the parent must not bump `refreshKey` on top.
+    await waitFor(() => expect(fetchAutopilotApplied).toHaveBeenCalledTimes(2))
+    await flushMicrotasks()
+    expect(fetchAutopilotApplied).toHaveBeenCalledTimes(2)
+  })
+
   it('hides Generate behind the plan callout when seo.inlineApply is off', async () => {
     render(<ProposalsTab planInfo={{ tier: 'starter', features: [], upgradeUrl: null }} />)
     await screen.findByText('Duplicate meta title')

package/src/__tests__/views/seo-settings.render.test.tsx

@@ -2,10 +2,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { fireEvent, render, screen, waitFor, within } from '@testing-library/react'
 
-// The SEO defaults tab reads six shared backends: /seo/config (meta defaults +
+// The SEO defaults tab reads eight shared backends: /seo/config (meta defaults +
 // verification), /seo/crawl-settings (sitemap toggles), /seo/sitemap/status
 // (read-only summary), /seo/index-status (environment), /seo/search-console
-// (Search data card), and /seo/digest-settings (Weekly SEO digest card).
+// (Search data card), /seo/geo-settings (AI visibility card),
+// /seo/autopilot/settings (SEO Autopilot card), and /seo/digest-settings
+// (Weekly SEO digest card).
 // `defaultApi` is the per-path route map; individual tests override the mock
 // implementation and delegate back to it for unrelated paths.
 type MockApiResponse = { data?: unknown; error?: string; status: number }
@@ -74,12 +76,37 @@ async function defaultApi(
       status: 200,
     }
   }
+  if (endpoint === '/seo/geo-settings' && method === 'GET') {
+    return { data: { enabled: true, retentionDays: 90 }, status: 200 }
+  }
   if (endpoint === '/seo/digest-settings' && method === 'GET') {
     return {
       data: { enabled: false, recipients: [], lastSentAt: null, lastError: null },
       status: 200,
     }
   }
+  if (endpoint === '/seo/autopilot/settings' && method === 'GET') {
+    return {
+      data: {
+        enabled: false,
+        enabledById: null,
+        pausedAt: null,
+        pausedReason: null,
+        types: {},
+        pausedTypes: {},
+        minBrandAlignment: 85,
+        redirectMinConfidence: 85,
+        maxPerRun: 5,
+        maxPerDay: 20,
+        verifyFailuresPerRun: 2,
+        outcomeWatch: { enabled: true, days: 14, dropRatio: 0.4, minPriorClicks: 50 },
+        lastRunAt: null,
+        lastRun: null,
+        governance: { issueFixApprovalRequired: false, redirectApprovalRequired: false },
+      },
+      status: 200,
+    }
+  }
   return { data: {}, status: 200 }
 }
 
@@ -98,6 +125,7 @@ vi.mock('sonner', () => ({
     success: (...args: unknown[]) => toastSuccess(...args),
     error: (...args: unknown[]) => toastError(...args),
     warning: vi.fn(),
+    info: vi.fn(),
     loading: vi.fn(),
   },
 }))
@@ -331,6 +359,40 @@ describe('SeoSettingsTab', () => {
     expect(body.serviceAccountKey).toContain('svc@acme.iam.gserviceaccount.com')
   })
 
+  it('renders Search data, AI visibility, SEO Autopilot, and the digest in that order', async () => {
+    render(<SeoSettingsTab role="ADMIN" />)
+    // Titles also render in the cards' skeleton states; wait for controls
+    // that only exist once each card's settings have loaded.
+    const toggle = await screen.findByRole('switch', { name: 'Enable autopilot' })
+    expect(toggle.getAttribute('aria-checked')).toBe('false')
+    const geoToggle = await screen.findByRole('switch', {
+      name: 'Record AI crawler and referral activity',
+    })
+    expect(geoToggle.getAttribute('aria-checked')).toBe('true')
+    const regions = screen
+      .getAllByRole('region')
+      .map((r) => r.getAttribute('aria-labelledby'))
+      .map((id) => (id ? document.getElementById(id)?.textContent : null))
+    const order = ['Search data', 'AI visibility', 'SEO Autopilot', 'Weekly SEO digest'].map((t) =>
+      regions.indexOf(t),
+    )
+    expect(order.every((i) => i >= 0)).toBe(true)
+    expect(order).toEqual([...order].sort((a, b) => a - b))
+  })
+
+  it('PUTs the AI visibility kill switch to /seo/geo-settings', async () => {
+    render(<SeoSettingsTab role="ADMIN" />)
+    fireEvent.click(
+      await screen.findByRole('switch', { name: 'Record AI crawler and referral activity' }),
+    )
+    await waitFor(() =>
+      expect(cmsApi).toHaveBeenCalledWith(
+        '/seo/geo-settings',
+        expect.objectContaining({ method: 'PUT', body: JSON.stringify({ enabled: false }) }),
+      ),
+    )
+  })
+
   it('renders the Weekly SEO digest card with the toggle off by default', async () => {
     render(<SeoSettingsTab role="ADMIN" />)
     expect(await screen.findByText('Weekly SEO digest')).toBeTruthy()
@@ -342,12 +404,13 @@ describe('SeoSettingsTab', () => {
 
   it('saves recipients as a trimmed, comma-split list', async () => {
     render(<SeoSettingsTab role="ADMIN" />)
-    await screen.findByText('Weekly SEO digest')
+    // 'Weekly SEO digest' is also the loading-state title; wait for the form.
+    const save = await screen.findByRole('button', { name: 'Save recipients' })
 
     fireEvent.change(screen.getByLabelText('Recipients'), {
       target: { value: ' a@x.com , b@x.com ' },
     })
-    fireEvent.click(screen.getByRole('button', { name: 'Save recipients' }))
+    fireEvent.click(save)
 
     await waitFor(() =>
       expect(cmsApi).toHaveBeenCalledWith(
@@ -370,9 +433,7 @@ describe('SeoSettingsTab', () => {
       return defaultApi(endpoint, options)
     })
     render(<SeoSettingsTab role="ADMIN" />)
-    await screen.findByText('Weekly SEO digest')
-
-    fireEvent.click(screen.getByRole('button', { name: /Send test digest/ }))
+    fireEvent.click(await screen.findByRole('button', { name: /Send test digest/ }))
 
     await waitFor(() =>
       expect(toastError).toHaveBeenCalledWith('No completed SEO audit yet — run an audit first'),

package/src/__tests__/views/seo-technical-tab.render.test.tsx

@@ -78,6 +78,21 @@ beforeEach(() => {
   pendingPut = null
 })
 
+describe('TechnicalTab AI crawler card', () => {
+  it('links to the AI visibility tab via onNavigate', async () => {
+    const onNavigate = vi.fn()
+    render(<TechnicalTab onNavigate={onNavigate} />)
+    fireEvent.click(await screen.findByRole('button', { name: /view trends/i }))
+    expect(onNavigate).toHaveBeenCalledWith('/seo/ai-visibility')
+  })
+
+  it('omits the trends link when the host gives no navigator', async () => {
+    render(<TechnicalTab />)
+    await screen.findByRole('switch', { name: /Audit rendered public HTML/i })
+    expect(screen.queryByRole('button', { name: /view trends/i })).toBeNull()
+  })
+})
+
 describe('TechnicalTab rendered audit setting', () => {
   it('renders the accessible setting and persists changes', async () => {
     render(<TechnicalTab />)

package/src/lib/api.ts

@@ -62,10 +62,27 @@ function appendLocaleParam(endpoint: string): string {
   return `${endpoint}${separator}locale=${encodeURIComponent(locale)}`
 }
 
+export interface CmsApiResult<T> {
+  data?: T
+  error?: string
+  /**
+   * Machine-readable error discriminator (e.g. IP_LOCKOUT_RISK, conflict) set
+   * by guard responses so callers can branch without parsing the message.
+   */
+  code?: string
+  /**
+   * The parsed non-2xx body, for the few endpoints that return structured
+   * detail beyond `error` / `code` (e.g. the 409 `fields` list from
+   * `/seo/autopilot/applied/:id/revert`). Callers must narrow it themselves.
+   */
+  errorBody?: unknown
+  status: number
+}
+
 export async function cmsApi<T = unknown>(
   endpoint: string,
   options: RequestInit = {},
-): Promise<{ data?: T; error?: string; code?: string; status: number }> {
+): Promise<CmsApiResult<T>> {
   const url = `${basePath}${appendLocaleParam(endpoint)}`
   const isFormData = typeof FormData !== 'undefined' && options.body instanceof FormData
 
@@ -98,9 +115,8 @@ export async function cmsApi<T = unknown>(
     if (!res.ok) {
       return {
         error: json.error || `Request failed (${res.status})`,
-        // Machine-readable error discriminator (e.g. IP_LOCKOUT_RISK) set by
-        // guard responses so callers can branch without parsing the message.
         code: typeof json.code === 'string' ? json.code : undefined,
+        errorBody: json,
         status: res.status,
       }
     }