@skyhook-io/radar-app 1.16.3 → 1.17.1

package/src/components/cnpg/CNPGOperatorConditions.test.tsx

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { expect, it, vi } from 'vitest'
+import { CNPGOperatorConditions } from './CNPGOperatorConditions'
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+it('starts folded and keeps every condition field, including unknown status and exact transition', () => {
+  vi.useFakeTimers(); vi.setSystemTime(new Date('2026-10-04T13:34:56Z'))
+  const host = document.createElement('div')
+  const root = createRoot(host)
+  act(() => root.render(<CNPGOperatorConditions conditions={[
+    { type: 'Ready', status: 'False', reason: 'Waiting', message: 'Waiting for the primary', lastTransitionTime: '2026-10-04T12:34:56Z' },
+    { type: 'ContinuousArchiving', status: 'Unknown', reason: 'Checking', message: 'Archive not checked yet' },
+  ]} />))
+  const button = host.querySelector('button')!
+  expect(button.textContent).toContain('Operator conditions')
+  expect(button.textContent).toContain('2 reported')
+  expect(button.getAttribute('aria-expanded')).toBe('false')
+  act(() => button.click())
+  expect(button.getAttribute('aria-expanded')).toBe('true')
+  for (const text of ['Ready', 'False', 'Waiting', 'Waiting for the primary', '1h ago', 'ContinuousArchiving', 'Unknown', 'Checking', 'Archive not checked yet', 'Last transition: Not reported']) expect(host.textContent).toContain(text)
+  expect(host.querySelector('time')?.getAttribute('datetime')).toBe('2026-10-04T12:34:56Z')
+  const badge = [...host.querySelectorAll('.badge-sm')].find((b) => b.textContent === 'False')
+  expect(badge).toBeDefined()
+  expect(badge?.className).not.toMatch(/success|warning|error/)
+  expect(badge?.className).toContain('bg-theme-hover/50 text-theme-text-secondary border-theme-border')
+  expect(badge?.className).not.toMatch(/emerald|amber|orange|red|sky-/)
+  const time = host.querySelector('time')!
+  act(() => time.parentElement!.dispatchEvent(new MouseEvent('mouseover', { bubbles: true })))
+  act(() => vi.advanceTimersByTime(1000))
+  expect(document.body.textContent).toContain('2026-10-04T12:34:56Z')
+  vi.useRealTimers()
+  act(() => root.unmount())
+})
+
+it('states that conditions have not been reported', () => {
+  const host = document.createElement('div')
+  const root = createRoot(host)
+  act(() => root.render(<CNPGOperatorConditions conditions={[]} />))
+  expect(host.textContent).toContain('No conditions reported')
+  expect(host.querySelector('button')!.getAttribute('aria-expanded')).toBe('false')
+  act(() => root.unmount())
+})

package/src/components/cnpg/CNPGOperatorConditions.tsx

@@ -0,0 +1,16 @@
+import { Badge, FactGrid, FactRow, FoldSection, Tooltip, formatAge } from '@skyhook-io/k8s-ui'
+
+export function CNPGOperatorConditions({ conditions }: { conditions: { type: string; status: string; reason?: string; message?: string; lastTransitionTime?: string }[] }) {
+  return (
+    <section className="mx-4 mb-4 rounded-xl border border-theme-border bg-theme-surface px-4 py-3 shadow-theme-sm">
+      <FoldSection title="Operator conditions" summary={conditions.length > 0 ? `${conditions.length} reported · status.conditions` : 'No conditions reported'} attention={false}>
+        <FactGrid>{conditions.map((c) => <FactRow key={c.type} label={<span className="inline-flex flex-wrap items-center gap-2">{c.type}<Badge severity="neutral" size="sm">{c.status}</Badge></span>}>
+          <div className="text-xs text-theme-text-secondary">Reason: {c.reason || 'Not reported'}</div>
+          <div className="break-words text-xs text-theme-text-secondary">{c.message || 'No message reported'}</div>
+          <div className="text-xs text-theme-text-tertiary">Last transition: {c.lastTransitionTime ? <Tooltip content={c.lastTransitionTime}><time dateTime={c.lastTransitionTime}>{formatAge(c.lastTransitionTime)} ago</time></Tooltip> : 'Not reported'}</div>
+        </FactRow>)}</FactGrid>
+        {conditions.length === 0 && <p className="text-sm text-theme-text-tertiary">The operator has not reported status.conditions.</p>}
+      </FoldSection>
+    </section>
+  )
+}

package/src/components/cnpg/CNPGOperatorConfig.test.tsx

@@ -0,0 +1,27 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { expect, it, vi } from 'vitest'
+import { ConfigBlock } from './CNPGOperator'
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+it('summarizes monitoring queries, then expands newline-preserving SQL with explicit truncation and inspection', () => {
+  const queries = `connections:\n  query: |\n    SELECT count(*)\n    FROM pg_stat_activity;\nlong_query:\n  query: '${'x'.repeat(8200)}'\n`
+  const inspect = vi.fn()
+  const host = document.createElement('div')
+  const root = createRoot(host)
+  act(() => root.render(<ConfigBlock config={{ kind: 'ConfigMap', namespace: 'operator', name: 'monitoring', purpose: 'monitoring', exists: true, readable: true, data: { queries } }} onInspect={inspect} />))
+  expect(host.textContent).toContain('2 queries · ConfigMap monitoring')
+  const fold = [...host.querySelectorAll('button')].find((b) => b.textContent?.includes('Query definitions'))!
+  expect(fold.getAttribute('aria-expanded')).toBe('false')
+  act(() => fold.click())
+  const preview = host.querySelector('pre')!
+  expect(preview.textContent).toBe(queries.slice(0, 8000))
+  expect(preview.classList.contains('whitespace-pre-wrap')).toBe(true)
+  expect(host.textContent).toContain(`Preview truncated to 8,000 of ${queries.length.toLocaleString()} characters`)
+  const link = [...host.querySelectorAll('button')].find((b) => b.textContent?.includes('Inspect ConfigMap'))!
+  act(() => link.click())
+  expect(inspect).toHaveBeenCalledWith({ kind: 'configmaps', group: '', namespace: 'operator', name: 'monitoring' })
+  act(() => root.unmount())
+})

package/src/components/cnpg/CNPGOperatorDiagnosis.tsx

@@ -0,0 +1,247 @@
+import type { ReactNode } from 'react'
+import { Badge, formatAge, type CNPGFleet } from '@skyhook-io/k8s-ui'
+import type { CNPGOperatorDiagnosis, CNPGOperatorReconcilePod, CNPGReadCoverage } from '../../api/cnpg-recovery'
+import { buildWorkloadPath } from '../../utils/navigation'
+import { GrantText, Mono, Sub } from '../workspace/layout'
+import { useCNPGNavigate } from './useCNPGNavigate'
+
+function Row({ label, children }: { label: string; children: ReactNode }) {
+  return (
+    <div className="grid grid-cols-[10rem_minmax(0,1fr)] gap-x-4 border-t border-theme-border px-4 py-2.5 first:border-t-0">
+      <div className="text-sm text-theme-text-tertiary">{label}</div>
+      <div className="min-w-0 text-sm text-theme-text-primary">{children}</div>
+    </div>
+  )
+}
+
+function Unread({ cov, what }: { cov: CNPGReadCoverage; what: string }) {
+  if (cov.state === 'denied' && cov.grant) {
+    return (
+      <span className="text-theme-text-tertiary">
+        No access to {what} · needs <GrantText grant={cov.grant} />
+      </span>
+    )
+  }
+  const text =
+    cov.state === 'denied'
+      ? `No access to ${what} (needs a grant you do not have)`
+      : cov.state === 'notFound'
+        ? `${what} not found`
+        : `${what} could not be read${cov.reason ? `: ${cov.reason}` : ''}`
+  return <span className="text-theme-text-tertiary">{text}</span>
+}
+
+function Leader({ d }: { d: CNPGOperatorDiagnosis }) {
+  const l = d.leader
+  if (l.state === 'disabled') return <span className="text-theme-text-secondary">Leader election is off ({l.reason}); run a single replica.</span>
+  if (l.state !== 'ok') return <Unread cov={{ state: l.state, grant: l.grant, reason: l.reason }} what={`Lease ${l.lease ?? ''}`.trim()} />
+  return (
+    <>
+      <div className="flex flex-wrap items-center gap-2">
+        {l.stale ? <Badge severity="error" size="sm">Not renewed</Badge> : <Badge severity="success" size="sm">Held</Badge>}
+        {l.holderPod ? <Mono>{l.holderPod}</Mono> : <span className="text-theme-text-tertiary">no holder</span>}
+        {l.holderPod && !l.holderIsCurrentPod && <span className="text-xs text-theme-text-tertiary">not one of the Deployment’s current Pods</span>}
+      </div>
+      <Sub>
+        Lease {l.lease}
+        {l.renewTime ? ` · renewed ${formatAge(l.renewTime)} ago` : ''}
+        {l.leaseDurationSeconds !== undefined ? ` · duration ${l.leaseDurationSeconds}s` : ''}
+        {l.transitions !== undefined ? ` · ${l.transitions} leader change${l.transitions === 1 ? '' : 's'}` : ''}
+        {l.stale ? ' · no operator instance is leading, so nothing reconciles' : ''}
+      </Sub>
+    </>
+  )
+}
+
+function Watch({ d, fleet }: { d: CNPGOperatorDiagnosis; fleet: CNPGFleet }) {
+  const w = d.watch
+  const outside = w.all || w.unresolved ? [] : fleet.rows.filter((r) => !w.namespaces.includes(r.namespace))
+  return (
+    <>
+      <div>{w.all ? 'All namespaces' : w.unresolved ? <span className="text-theme-text-secondary">{w.unresolved}</span> : w.namespaces.join(', ')}</div>
+      <Sub>{w.source}</Sub>
+      {outside.length > 0 && (
+        <div className="mt-1 text-xs text-theme-text-secondary">
+          Not reconciled by this operator: {outside.map((r) => `${r.namespace}/${r.name}`).join(', ')}
+        </div>
+      )}
+    </>
+  )
+}
+
+function Webhooks({ d }: { d: CNPGOperatorDiagnosis }) {
+  return (
+    <div className="space-y-2">
+      {d.webhooks.map((cfg) => {
+        if (cfg.state !== 'ok') {
+          return (
+            <div key={cfg.name}>
+              <div className="text-xs text-theme-text-secondary">{cfg.kind}</div>
+              {cfg.state === 'notFound' ? (
+                <span className="text-theme-text-secondary">
+                  <Mono>{cfg.name}</Mono> is missing: the operator recreates it at startup; until then CloudNativePG objects are not validated or defaulted.
+                </span>
+              ) : (
+                <Unread cov={cfg} what={cfg.name} />
+              )}
+            </div>
+          )
+        }
+        const noCA = cfg.webhooks.filter((w) => !w.caBundleSet && !w.url)
+        const policies = [...new Set(cfg.webhooks.map((w) => w.failurePolicy))]
+        return (
+          <div key={cfg.name}>
+            <div className="text-xs text-theme-text-secondary">{cfg.kind}</div>
+            <div>
+              <Mono>{cfg.name}</Mono> · {cfg.webhooks.length} webhook{cfg.webhooks.length === 1 ? '' : 's'} · failurePolicy {policies.join(', ')}
+            </div>
+            {noCA.length > 0 ? (
+              <div className="text-xs text-theme-text-secondary">No CA bundle on {noCA.map((w) => w.name).join(', ')}: the apiserver cannot verify the webhook, so calls fail.</div>
+            ) : (
+              <Sub>CA bundle set on every webhook</Sub>
+            )}
+          </div>
+        )
+      })}
+      {d.webhookServices.map((svc) => {
+        const failClosed = d.webhooks.some((c) => c.webhooks.some((w) => w.service === `${svc.namespace}/${svc.name}` && w.failurePolicy === 'Fail'))
+        return (
+          <div key={`${svc.namespace}/${svc.name}`}>
+            <div className="text-xs text-theme-text-secondary">Service {svc.namespace}/{svc.name}</div>
+            {svc.state !== 'ok' || svc.readyEndpoints === null ? (
+              <Unread cov={svc} what="its endpoints" />
+            ) : svc.readyEndpoints > 0 ? (
+              <div>
+                {svc.readyEndpoints} ready endpoint{svc.readyEndpoints === 1 ? '' : 's'}
+                {svc.notReadyEndpoints ? <span className="text-theme-text-tertiary"> · {svc.notReadyEndpoints} not ready</span> : null}
+              </div>
+            ) : (
+              <div className="flex flex-wrap items-center gap-2">
+                <Badge severity="error" size="sm">No ready endpoint</Badge>
+                <span className="text-xs text-theme-text-secondary">
+                  {failClosed ? 'With failurePolicy Fail, every create or update of a CloudNativePG object is rejected until the operator is ready.' : 'Webhook calls are skipped (failurePolicy Ignore).'}
+                </span>
+              </div>
+            )}
+          </div>
+        )
+      })}
+    </div>
+  )
+}
+
+function Reconcile({ pods }: { pods: CNPGOperatorReconcilePod[] }) {
+  if (pods.length === 0) return <span className="text-theme-text-tertiary">No operator Pods visible</span>
+  return (
+    <div className="space-y-3">
+      {pods.map((p) => (
+        <div key={p.pod}>
+          <div className="flex flex-wrap items-center gap-2">
+            <Mono>{p.pod}</Mono>
+            {p.leader && <Badge severity="info" size="sm">leader</Badge>}
+            <span className="text-xs text-theme-text-tertiary">
+              {p.state === 'ok' || p.state === 'partial'
+                ? p.startedAt
+                  ? `counters since the operator container started ${formatAge(p.startedAt)} ago`
+                  : 'counters since the operator container last started'
+                : null}
+              {!p.leader ? `${p.state === 'ok' || p.state === 'partial' ? ' · ' : ''}only the leader reconciles` : ''}
+            </span>
+          </div>
+          {p.state !== 'ok' && p.state !== 'partial' ? (
+            <span className="text-xs text-theme-text-tertiary">{p.error ?? p.state}</span>
+          ) : (
+            <table className="mt-1 w-full max-w-lg text-left text-xs">
+              <thead className="text-theme-text-tertiary">
+                <tr>
+                  <th className="py-0.5 font-normal">Controller</th>
+                  <th className="py-0.5 font-normal">Reconciles</th>
+                  <th className="py-0.5 font-normal">Errors</th>
+                </tr>
+              </thead>
+              <tbody>
+                {p.controllers.map((c) => (
+                  <tr key={c.controller} className="border-t border-theme-border">
+                    <td className="py-0.5 font-mono">{c.controller}</td>
+                    <td className="py-0.5">{c.total === null ? '—' : Math.round(c.total).toLocaleString()}</td>
+                    <td className="py-0.5">
+                      {c.errors === null ? '—' : c.errors > 0 ? <span className="font-medium text-theme-text-primary">{Math.round(c.errors).toLocaleString()}</span> : '0'}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          )}
+          {p.reason && <Sub>{p.reason}</Sub>}
+        </div>
+      ))}
+      <Sub>From controller-runtime metrics on the operator’s metrics port, read through pods/proxy. Errors are cumulative; a count that grows between refreshes is the signal.</Sub>
+    </div>
+  )
+}
+
+/**
+ * Why a Cluster may not be reconciling, from the operator's side: leader
+ * Lease, watched namespaces, webhook reachability, reconcile errors and
+ * recent events. Each fact reports its own access.
+ */
+export function CNPGOperatorDiagnosisSection({ diagnosis, fleet }: { diagnosis: CNPGOperatorDiagnosis[]; fleet: CNPGFleet }) {
+  const navigate = useCNPGNavigate()
+  if (diagnosis.length === 0) return null
+  return (
+    <>
+      {diagnosis.map((d) => {
+        const warnings = d.events.items.filter((e) => e.type === 'Warning')
+        return (
+          <section key={`${d.namespace}/${d.deployment}`}>
+            <div className="mb-2 flex flex-wrap items-baseline gap-2">
+              <h2 className="text-sm font-semibold text-theme-text-primary">Operator diagnosis</h2>
+              <span className="text-xs text-theme-text-tertiary">
+                Deployment {d.deployment} in {d.namespace}
+              </span>
+              <button
+                type="button"
+                onClick={() => navigate(buildWorkloadPath({ kind: 'deployments', namespace: d.namespace, name: d.deployment, tab: 'logs' }))}
+                className="ml-auto text-xs text-accent-text hover:underline"
+              >
+                Operator logs
+              </button>
+            </div>
+            <div className="overflow-hidden rounded-xl border border-theme-border bg-theme-surface shadow-theme-sm">
+              <Row label="Leader">
+                <Leader d={d} />
+              </Row>
+              <Row label="Watched namespaces">
+                <Watch d={d} fleet={fleet} />
+              </Row>
+              <Row label="Admission webhooks">
+                <Webhooks d={d} />
+              </Row>
+              <Row label="Reconcile errors">
+                {d.podCoverage.state !== 'ok' ? <Unread cov={d.podCoverage} what="the operator Pods" /> : <Reconcile pods={d.reconcile} />}
+              </Row>
+              <Row label="Recent events">
+                {d.events.state !== 'ok' ? (
+                  <Unread cov={d.events} what={`events in ${d.namespace}`} />
+                ) : d.events.items.length === 0 ? (
+                  <span className="text-theme-text-tertiary">None retained for the operator’s Deployment, ReplicaSets or Pods</span>
+                ) : (
+                  <ul className="space-y-1">
+                    {[...warnings, ...d.events.items.filter((e) => e.type !== 'Warning')].slice(0, 8).map((e, i) => (
+                      <li key={`${e.kind}/${e.name}/${e.reason}/${i}`} className="text-xs text-theme-text-secondary">
+                        {e.type === 'Warning' && <Badge severity="warning" size="sm">Warning</Badge>}{' '}
+                        <span className="font-medium text-theme-text-primary">{e.reason}</span> on {e.kind} {e.name}
+                        {e.lastSeen ? ` · ${formatAge(e.lastSeen)} ago` : ''}
+                        {e.count > 1 ? ` · ×${e.count}` : ''}: {e.message}
+                      </li>
+                    ))}
+                  </ul>
+                )}
+              </Row>
+            </div>
+          </section>
+        )
+      })}
+    </>
+  )
+}

package/src/components/cnpg/CNPGOverview.test.tsx

@@ -0,0 +1,171 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { describe, expect, it, vi } from 'vitest'
+import { buildCNPGFleet, CNPG_WORKSPACE_KEYS, type CNPGKindCoverage, type CNPGWorkspaceResponse } from '@skyhook-io/k8s-ui'
+
+const sidebar = vi.hoisted(() => ({ data: undefined as CNPGWorkspaceResponse | undefined }))
+vi.mock('../../api/cnpg', () => ({ useCNPGWorkspace: () => ({ data: sidebar.data }) }))
+vi.mock('../../api/cnpg-storage', () => ({ useCNPGFleetDisk: () => ({}) }))
+vi.mock('../../api/cnpg-history', () => ({ useCNPGFleetMetrics: () => ({}) }))
+vi.mock('../../api/client', () => ({ useRadarFeature: () => ({ support: 'supported' }) }))
+
+vi.mock('../../context/ConnectionContext', () => ({ useConnection: () => ({ connection: { context: 'kind-test' } }) }))
+vi.mock('./CNPGOperatorBanner', () => ({ CNPGOperatorBanner: () => null }))
+
+const { CNPGOverview } = await import('./CNPGOverview')
+const { useCNPGSidebarWorkspace } = await import('./useCNPGSidebarWorkspace')
+
+const cluster = (namespace: string, name: string) => ({
+  apiVersion: 'postgresql.cnpg.io/v1',
+  kind: 'Cluster',
+  metadata: { namespace, name },
+  spec: { instances: 1 },
+  status: { phase: 'Cluster in healthy state', readyInstances: 1 },
+})
+
+function response(clusters: ReturnType<typeof cluster>[], coverage: CNPGKindCoverage = { state: 'full' }): CNPGWorkspaceResponse {
+  return { installed: true, context: 'kind-test', namespaces: null, coverage: { clusters: coverage }, objects: { clusters }, issues: [], audit: [], backupsOmitted: 0 }
+}
+
+function render(resp: CNPGWorkspaceResponse, query = '', opts: { attention?: string[]; onCreate?: () => void; namespaces?: string[] } = {}) {
+  const fleet = buildCNPGFleet(resp)
+  for (const row of fleet.rows) row.attention = !!opts.attention?.includes(row.name)
+  fleet.attentionCount = fleet.rows.filter((r) => r.attention).length
+  return renderToStaticMarkup(
+    <MemoryRouter>
+      <CNPGOverview
+        data={resp}
+        fleet={fleet}
+        namespaces={opts.namespaces ?? []}
+        searchParams={new URLSearchParams(query)}
+        onSetParams={() => {}}
+        onInspect={() => {}}
+        inspected={null}
+        onClearNamespaces={() => {}}
+        onCreate={opts.onCreate}
+      />
+    </MemoryRouter>,
+  )
+}
+
+describe('CNPGOverview is the list of clusters', () => {
+  const two = response([cluster('pg', 'pg-bad'), cluster('pg', 'pg-good')])
+
+  it('lists every cluster unless asked for less, healthy ones included', () => {
+    const html = render(two, '', { attention: ['pg-bad'] })
+    expect(html).toContain('pg-bad')
+    expect(html).toContain('pg-good')
+    expect(html).toMatch(/aria-selected="true"[^>]*>All clusters/)
+  })
+
+  it('narrows to the clusters that need attention when asked', () => {
+    const html = render(two, 'filter=attention', { attention: ['pg-bad'] })
+    expect(html).toContain('pg-bad')
+    expect(html).not.toContain('pg-good')
+  })
+
+  it('counts a partly read list as a floor', () => {
+    const html = render(response([cluster('a', 'pg-a')], { state: 'partial', allowedNamespaces: ['a'] }))
+    expect(html).toContain('≥1 PostgreSQL cluster')
+  })
+
+  it('says what was not read instead of claiming there are no clusters', () => {
+    const html = render(response([], { state: 'uncached', uncachedNamespaces: ['c'] }))
+    expect(html).toContain('No visible PostgreSQL clusters')
+    expect(html).toContain('Radar does not cache PostgreSQL clusters in c')
+    expect(html).not.toContain('No PostgreSQL clusters in kind-test')
+  })
+
+  it('limits an empty read to the selected scope and keeps partial coverage distinct', () => {
+    const html = render(response([]), '', { namespaces: ['db', 'prod'] })
+    expect(html).toContain('No PostgreSQL clusters in the selected namespaces')
+    expect(html).toContain('None in db, prod in kind-test')
+    expect(html).not.toContain('No PostgreSQL clusters in kind-test')
+    expect(render(response([]))).toContain('No PostgreSQL clusters in kind-test')
+    expect(render(response([], { state: 'partial' }), '', { namespaces: ['db'] })).toContain('No visible PostgreSQL clusters')
+  })
+
+  it('says once, for the whole list, why no volume usage is measured', () => {
+    const resp = response([cluster('pg', 'pg-a'), cluster('pg', 'pg-b')])
+    const fleet = buildCNPGFleet(resp)
+    for (const row of fleet.rows) row.disk = { text: 'not measured', tone: 'unknown', source: 'no claims owned by this cluster' }
+    const html = renderToStaticMarkup(
+      <MemoryRouter>
+        <CNPGOverview data={resp} fleet={fleet} namespaces={[]} searchParams={new URLSearchParams()} onSetParams={() => {}} onInspect={() => {}} inspected={null} onClearNamespaces={() => {}} />
+      </MemoryRouter>,
+    )
+    expect(html).toContain('not measured for any cluster here (no claims owned by them)')
+  })
+
+  it('offers Create when the host can create', () => {
+    expect(render(two, '', { onCreate: () => {} })).toContain('Create')
+    expect(render(two)).not.toMatch(/>Create</)
+  })
+
+  it('names missing operator readiness and separately shows observed zero ready instance Pods', () => {
+    const analytics = cluster('db', 'analytics')
+    delete (analytics.status as Partial<typeof analytics.status>).readyInstances
+    const resp = response([analytics])
+    resp.coverage.pods = { state: 'full' }
+    resp.objects.pods = []
+    const html = render(resp)
+    expect(html).toContain('Not reported by the operator')
+    expect(html).toContain('0 of 1 instance Pods ready')
+    expect(html).not.toContain('–/1')
+  })
+
+  it('does not turn unread Pod readiness into an observed zero', () => {
+    const analytics = cluster('db', 'analytics')
+    delete (analytics.status as Partial<typeof analytics.status>).readyInstances
+    const resp = response([analytics])
+    resp.coverage.pods = { state: 'denied' }
+    const html = render(resp)
+    expect(html).toContain('Not reported by the operator')
+    expect(html).not.toContain('instance Pods ready')
+    expect(html).not.toContain('–/1')
+  })
+
+  it('keeps reported operator readiness as a ratio', () => {
+    expect(render(response([cluster('db', 'payments')]))).toContain('1/1')
+  })
+})
+
+it('qualifies heading, attention filter and category counts on both fleet routes', () => {
+  const resp = response([cluster('prod', 'orders')], { state: 'partial', allowedNamespaces: ['prod'] })
+  const fleet = buildCNPGFleet(resp)
+  fleet.attentionCount = 1; fleet.categoryCounts.availability = 1
+  const html = renderToStaticMarkup(<MemoryRouter><CNPGOverview data={resp} fleet={fleet} namespaces={[]} searchParams={new URLSearchParams()} onSetParams={() => {}} onInspect={() => {}} inspected={null} onClearNamespaces={() => {}} /></MemoryRouter>)
+  expect(html).toContain('≥1 need attention')
+  expect(html).toMatch(/Needs attention<span[^>]*>≥1</)
+  expect(html).toMatch(/Availability<span[^>]*>≥1</)
+  expect(render(resp)).toMatch(/Needs attention<span[^>]*>Unknown</)
+  expect(render(resp)).toContain('Needs attention: unknown')
+  expect(render(resp)).not.toContain('Unknown need attention')
+})
+
+it('does not claim an empty partial attention filter proves no clusters need attention', () => {
+  const html = render(response([cluster('prod', 'orders')], { state: 'partial', allowedNamespaces: ['prod'] }), 'filter=attention')
+  expect(html).toContain('No attention findings in the readable data; other data was not read.')
+  expect(html).not.toContain('No clusters need attention.')
+})
+
+it('uses an unknown sidebar count and tooltip for zero over partial coverage', () => {
+  sidebar.data = { installed: true, context: 'kind-test', namespaces: null, coverage: Object.fromEntries(CNPG_WORKSPACE_KEYS.map((k) => [k, { state: 'full' }])), objects: {}, issues: [], audit: [], backupsOmitted: 0 }
+  const result = { value: undefined as ReturnType<typeof useCNPGSidebarWorkspace> }
+  function Probe() {
+    result.value = useCNPGSidebarWorkspace({ apiResources: [{ group: 'postgresql.cnpg.io' }] as any, namespaces: [] })
+    return null
+  }
+  sidebar.data.coverage.clusters = { state: 'partial' }
+  renderToStaticMarkup(<MemoryRouter><Probe /></MemoryRouter>)
+  for (const d of result.value!.CloudNativePG.destinations.filter((d) => d.id !== 'operator')) {
+    expect(d.count).toBeNull()
+    expect(d.countLowerBound).toBe(true)
+    expect(d.countTitle).toMatch(/^Unknown: some CloudNativePG data could not be read\./)
+    expect(d.countTitle).not.toContain('At least 0')
+  }
+  sidebar.data.coverage.clusters = { state: 'full' }
+  renderToStaticMarkup(<MemoryRouter><Probe /></MemoryRouter>)
+  expect(result.value!.CloudNativePG.destinations.find((d) => d.id === 'protection')!.count).toBe(0)
+  sidebar.data = undefined
+})