@skyhook-io/k8s-ui 1.16.3 → 1.17.1

package/src/components/cnpg/pooler.ts

@@ -0,0 +1,225 @@
+import type { Fact } from '../facts'
+import type { HealthLevel } from '../resources/resource-utils'
+import { formatGrant, type Grant } from '../../utils/grant'
+
+/** The Deployment a Pooler runs, as the host read it. */
+export interface CNPGPoolerDeploymentLive {
+  name: string
+  state: 'ok' | 'missing' | 'unreadable' | 'foreign'
+  replicas?: number
+  readyReplicas?: number
+  updatedReplicas?: number
+  availableReplicas?: number
+}
+
+export interface CNPGPoolerServiceLive {
+  name: string
+  state: 'ok' | 'missing' | 'unreadable' | 'foreign'
+  type?: string
+  port?: number
+}
+
+export interface CNPGPoolerPoolSample {
+  database: string
+  user: string
+  clActive?: number
+  clWaiting?: number
+  svActive?: number
+  svIdle?: number
+  svUsed?: number
+  maxwaitSeconds?: number
+  poolMode?: string
+}
+
+/** Live PgBouncer exporter reads, one per pooler Pod. */
+export interface CNPGPoolerPressureLive {
+  state: 'loading' | 'denied' | 'error' | 'ok'
+  reason?: string
+  pods: { pod: string; state: string; error?: string; reason?: string; schedulingReason?: string; pools?: CNPGPoolerPoolSample[] }[]
+}
+
+/** Each PgBouncer's own SHOW STATE. */
+export interface CNPGPoolerObservedLive {
+  state: 'loading' | 'denied' | 'error' | 'ok'
+  grant?: Grant
+  reason?: string
+  pods: { pod: string; state: string; paused?: boolean; error?: string }[]
+}
+
+/**
+ * What a host that reads the cluster adds to the Pooler summary. Each part is
+ * optional: a part the host does not provide keeps the resource-only wording.
+ */
+export interface CNPGPoolerLive {
+  deployment?: CNPGPoolerDeploymentLive
+  service?: CNPGPoolerServiceLive
+  pressure?: CNPGPoolerPressureLive
+  observed?: CNPGPoolerObservedLive
+}
+
+export interface CNPGPoolerReadiness {
+  text: string
+  level: HealthLevel
+  detail?: string
+}
+
+/** Readiness from the Pooler's Deployment; the Pooler's status only counts scheduled Pods. */
+export function poolerReadiness(d: CNPGPoolerDeploymentLive | undefined): CNPGPoolerReadiness {
+  if (!d) return { text: 'Unknown', level: 'unknown', detail: 'Readiness is on the Pooler’s Deployment, which was not read' }
+  switch (d.state) {
+    case 'missing':
+      return { text: 'No Deployment', level: 'unhealthy', detail: `Deployment ${d.name} does not exist` }
+    case 'unreadable':
+      return { text: 'Unknown', level: 'unknown', detail: `No access to Deployment ${d.name}` }
+    case 'foreign':
+      return { text: 'Unknown', level: 'unknown', detail: `Deployment ${d.name} is not controlled by this Pooler` }
+  }
+  const want = d.replicas ?? 0
+  const ready = d.readyReplicas ?? 0
+  const detail = `from Deployment ${d.name}`
+  if (want === 0) return { text: 'Scaled to zero', level: 'neutral', detail }
+  if (ready === 0) return { text: `0/${want} ready`, level: 'unhealthy', detail }
+  if (ready < want) return { text: `${ready}/${want} ready`, level: 'degraded', detail }
+  return { text: `${ready}/${want} ready`, level: 'healthy', detail }
+}
+
+export interface CNPGPoolerPoolRow {
+  database: string
+  user: string
+  poolModes: string[]
+  clActive?: number
+  clWaiting?: number
+  svActive?: number
+  svIdle?: number
+  svUsed?: number
+  maxwaitSeconds?: number
+  /** Pods whose exporter reported this pool. */
+  pods: number
+}
+
+/**
+ * One row per database/user pool, summed over the Pods that reported it
+ * (max wait is the maximum). A field no Pod reported stays undefined.
+ */
+export function aggregatePoolerPools(pods: CNPGPoolerPressureLive['pods']): CNPGPoolerPoolRow[] {
+  const rows = new Map<string, CNPGPoolerPoolRow>()
+  const add = (a: number | undefined, b: number | undefined) => (b === undefined ? a : (a ?? 0) + b)
+  for (const p of pods) {
+    for (const pool of p.pools ?? []) {
+      const key = `${pool.database}\u0000${pool.user}`
+      const row = rows.get(key) ?? { database: pool.database, user: pool.user, poolModes: [], pods: 0 }
+      row.pods++
+      row.clActive = add(row.clActive, pool.clActive)
+      row.clWaiting = add(row.clWaiting, pool.clWaiting)
+      row.svActive = add(row.svActive, pool.svActive)
+      row.svIdle = add(row.svIdle, pool.svIdle)
+      row.svUsed = add(row.svUsed, pool.svUsed)
+      if (pool.maxwaitSeconds !== undefined) row.maxwaitSeconds = Math.max(row.maxwaitSeconds ?? 0, pool.maxwaitSeconds)
+      if (pool.poolMode && !row.poolModes.includes(pool.poolMode)) row.poolModes.push(pool.poolMode)
+      rows.set(key, row)
+    }
+  }
+  return [...rows.values()].sort((a, b) => a.database.localeCompare(b.database) || a.user.localeCompare(b.user))
+}
+
+export interface CNPGPoolerPodRow {
+  pod: string
+  /** ok | partial | the read's failure state. */
+  state: string
+  error?: string
+  clActive?: number
+  clWaiting?: number
+  svActive?: number
+  maxwaitSeconds?: number
+}
+
+/**
+ * Each PgBouncer Pod's own totals across its pools, so one saturated Pod is
+ * not hidden in the sum. A Pod that did not report keeps its state and no
+ * numbers; a field none of its pools reported stays undefined.
+ */
+export function poolerPodPressure(pods: CNPGPoolerPressureLive['pods']): CNPGPoolerPodRow[] {
+  const add = (a: number | undefined, b: number | undefined) => (b === undefined ? a : (a ?? 0) + b)
+  return pods
+    .map((p) => {
+      const row: CNPGPoolerPodRow = { pod: p.pod, state: p.state, error: p.error }
+      for (const pool of p.pools ?? []) {
+        row.clActive = add(row.clActive, pool.clActive)
+        row.clWaiting = add(row.clWaiting, pool.clWaiting)
+        row.svActive = add(row.svActive, pool.svActive)
+        if (pool.maxwaitSeconds !== undefined) row.maxwaitSeconds = Math.max(row.maxwaitSeconds ?? 0, pool.maxwaitSeconds)
+      }
+      return row
+    })
+    .sort((a, b) => a.pod.localeCompare(b.pod))
+}
+
+/**
+ * PgBouncer settings worth showing, with the value PgBouncer uses when the
+ * Pooler leaves one unset. Defaults are named only where they were read from
+ * PgBouncer itself (SHOW CONFIG on PgBouncer 1.24); CloudNativePG writes only
+ * the parameters the Pooler sets.
+ */
+export const POOLER_LIMIT_PARAMETERS: { key: string; label: string; pgbouncerDefault?: string }[] = [
+  { key: 'default_pool_size', label: 'Pool size (per database/user)', pgbouncerDefault: '20' },
+  { key: 'max_client_conn', label: 'Max client connections', pgbouncerDefault: '100' },
+  { key: 'max_db_connections', label: 'Max connections per database', pgbouncerDefault: '0 (unlimited)' },
+  { key: 'max_user_connections', label: 'Max connections per user', pgbouncerDefault: '0 (unlimited)' },
+  { key: 'reserve_pool_size', label: 'Reserve pool', pgbouncerDefault: '0' },
+  { key: 'min_pool_size', label: 'Min pool size', pgbouncerDefault: '0' },
+]
+
+/** The Cluster Service PgBouncer forwards to, by the Pooler's type. */
+export function poolerBackendService(cluster: string | undefined, type: string | undefined): string | undefined {
+  if (!cluster || !type) return undefined
+  if (type === 'rw' || type === 'ro' || type === 'r') return `${cluster}-${type}`
+  return undefined
+}
+
+/** Observed pause across PgBouncers: every one, none, some, or unknown. */
+export function observedPause(o: CNPGPoolerObservedLive | undefined): { text: string; level: HealthLevel } | null {
+  if (!o) return null
+  if (o.state === 'loading') return { text: 'Reading…', level: 'unknown' }
+  if (o.state === 'denied') return { text: `Not observable: needs ${formatGrant(o.grant) ?? 'create pods/exec'}`, level: 'unknown' }
+  if (o.state === 'error') return { text: `Not observable: ${o.reason ?? 'read failed'}`, level: 'unknown' }
+  if (o.pods.length === 0) return { text: 'No PgBouncer Pods', level: 'unknown' }
+  const read = o.pods.filter((p) => p.state === 'ok' && p.paused !== undefined)
+  const paused = read.filter((p) => p.paused).length
+  const unread = o.pods.length - read.length
+  const tail = unread > 0 ? ` · ${unread} not read: ${o.pods.filter((p) => p.state !== 'ok' || p.paused === undefined).map((p) => `${p.pod} (${p.error ?? p.state})`).join('; ')}` : ''
+  if (read.length === 0) return { text: `Not observable${tail}`, level: 'unknown' }
+  if (paused === 0) return { text: `Serving (not paused) on ${read.length} of ${o.pods.length} PgBouncers${tail}`, level: unread ? 'unknown' : 'healthy' }
+  if (paused === read.length) return { text: `Paused on ${paused} of ${o.pods.length} PgBouncers${tail}`, level: 'degraded' }
+  return { text: `Paused on ${paused} of ${o.pods.length} PgBouncers${tail}`, level: 'alert' }
+}
+
+export function poolerPressureCoverage(pods: CNPGPoolerPressureLive['pods']) {
+  const reporting = pods.filter((p) => p.state === 'ok' || p.state === 'partial')
+  const complete = pods.length > 0 && pods.every((p) => p.state === 'ok')
+  const gaps = pods.filter((p) => p.state !== 'ok').map((p) => {
+    const reason = [p.reason, p.error].filter(Boolean).join(' · ')
+    return `${p.pod}: ${p.state === 'partial' ? 'partial' : 'not read'}${reason ? ` (${reason})` : p.state === 'partial' ? '' : ` (${p.state})`}`
+  })
+  return {
+    reporting,
+    complete,
+    limitation: gaps.join('; ') || (pods.length === 0 ? 'No PgBouncer Pods answered' : undefined),
+    empty: complete ? 'Idle: no client pools open' : 'No pools seen in what was read',
+  }
+}
+
+type PoolerMetric = 'clActive' | 'clWaiting' | 'svActive' | 'svIdle' | 'svUsed' | 'maxwaitSeconds'
+
+export function poolerPressureFact(pods: CNPGPoolerPressureLive['pods'], field: PoolerMetric, pool?: { database: string; user: string }): Fact {
+  const coverage = poolerPressureCoverage(pods)
+  const pools = coverage.reporting.flatMap((p) => p.pools ?? []).filter((p) => !pool || (p.database === pool.database && p.user === pool.user))
+  const values = pools.map((p) => p[field]).filter((v): v is number => v !== undefined)
+  const complete = coverage.complete && values.length === pools.length
+  const value = field === 'maxwaitSeconds' ? Math.max(0, ...values) : values.reduce((a, b) => a + b, 0)
+  const label = { clActive: 'Active clients', clWaiting: 'Waiting clients', svActive: 'Active servers', svIdle: 'Idle servers', svUsed: 'Used servers', maxwaitSeconds: 'Max wait' }[field]
+  if ((!complete && value === 0) || (pools.length > 0 && values.length === 0)) {
+    return { text: 'Unknown', tone: 'unknown', source: coverage.limitation ?? `${label} not reported for every pool` }
+  }
+  const text = field === 'maxwaitSeconds' ? `${value.toFixed(1)} s` : String(value)
+  return { text: `${complete ? '' : '≥'}${text}`, tone: field === 'clWaiting' && value > 0 ? 'degraded' : complete ? 'neutral' : 'unknown', source: complete ? undefined : coverage.limitation ?? `${label} not reported for every pool` }
+}

package/src/components/cnpg/primitives.tsx

@@ -1,134 +1,38 @@
-import type { ReactNode } from 'react'
 import { clsx } from 'clsx'
-import type { HealthLevel } from '../resources/resource-utils'
-import { formatAge } from '../resources/resource-utils'
+import { toneTextClass } from '../ui/status-tone'
+import type { ComponentProps } from 'react'
+import type { ResourceRef } from '../../types/core'
+import { WorkspaceProblemCallout } from '../problems'
+import type { CNPGProblem } from './workspace'
+import { cnpgProblemForPresentation } from './problems'
 import { StatusDot } from '../ui/status-tone'
-import { Tooltip } from '../ui/Tooltip'
-import { AlertBanner } from '../ui/drawer-components'
-import { TONE_TEXT_CLASS } from '../ui/severity-tone'
-import type { CNPGFact, CNPGProblem } from './workspace'
 
-export interface CNPGRef {
-  kind: string
-  group?: string
-  namespace: string
-  name: string
-}
-
-export type CNPGNavigate = (ref: CNPGRef) => void
-
-const TONE_TEXT: Record<HealthLevel, string> = {
-  healthy: 'text-theme-text-primary',
-  degraded: TONE_TEXT_CLASS.amber,
-  alert: TONE_TEXT_CLASS.orange,
-  unhealthy: TONE_TEXT_CLASS.red,
-  unknown: 'text-theme-text-tertiary',
-  neutral: 'text-theme-text-secondary',
-}
+export { FactValue, FactSource, FactGrid, FactRow } from '../facts'
+export { RefLink, type NavigateToRef as CNPGNavigate } from '../ui/RefLink'
+export { SectionHeading as SummaryHeading } from '../ui/FoldSection'
+export { toneTextClass } from '../ui/status-tone'
+export type CNPGRef = ResourceRef
+export { CNPG_PROBLEM_TONE, cnpgProblemForPresentation } from './problems'
 
 export const CNPG_PRIMARY_BUTTON = 'btn-brand inline-flex items-center gap-1.5 px-3 py-1.5 text-sm font-medium'
 export const CNPG_SECONDARY_BUTTON =
   'inline-flex items-center gap-1.5 rounded-lg border border-theme-border bg-theme-surface px-3 py-1.5 text-sm text-theme-text-primary transition-colors hover:bg-theme-hover'
 
-export function toneTextClass(tone: HealthLevel): string {
-  return TONE_TEXT[tone]
-}
-
-export function FactValue({ fact, className }: { fact: CNPGFact; className?: string }) {
-  const age = fact.at ? formatAge(fact.at) : null
-  const body = (
-    <span className={clsx(toneTextClass(fact.tone), className)}>
-      {fact.text}
-      {age && <span className="text-theme-text-secondary">{fact.text ? ' · ' : ''}{age} ago</span>}
-    </span>
-  )
-  if (!fact.source && !fact.at) return body
-  return (
-    <Tooltip content={[fact.at ? new Date(fact.at).toUTCString() : null, fact.source].filter(Boolean).join(' · ')} position="top">
-      {body}
-    </Tooltip>
-  )
-}
-
-export function FactSource({ fact }: { fact: CNPGFact }) {
-  if (!fact.source) return null
-  return <div className="mt-0.5 text-[11.5px] text-theme-text-tertiary">{fact.source}</div>
-}
 
-export function FactGrid({ children }: { children: ReactNode }) {
-  return <dl className="grid grid-cols-[9.5rem_minmax(0,1fr)] gap-x-4 gap-y-2 text-sm">{children}</dl>
+export function ProblemCallout({ problem, ...props }: Omit<ComponentProps<typeof WorkspaceProblemCallout>, 'rootKind' | 'problem'> & { problem: CNPGProblem }) {
+  return <WorkspaceProblemCallout {...props} problem={cnpgProblemForPresentation(problem)} rootKind="Cluster" />
 }
 
-export function FactRow({ label, children }: { label: ReactNode; children: ReactNode }) {
-  return (
-    <>
-      <dt className="text-theme-text-tertiary">{label}</dt>
-      <dd className="min-w-0 break-words text-theme-text-primary">{children}</dd>
-    </>
-  )
+export function ToneDot({ tone }: Pick<ComponentProps<typeof StatusDot>, 'tone'>) {
+  return <StatusDot tone={tone} size="sm" />
 }
 
-export function SummaryHeading({ children, hint }: { children: ReactNode; hint?: ReactNode }) {
+/** status.currentPrimary and the primary role label disagree: both are named rather than one silently winning. */
+export function PrimaryConflictNote({ conflict }: { conflict: { status: string; labelled: string } }) {
   return (
-    <div className="mb-2 mt-5 flex items-baseline gap-2 first:mt-0">
-      <h3 className="text-[11px] font-semibold uppercase tracking-wide text-theme-text-tertiary">{children}</h3>
-      {hint && <span className="text-[11px] text-theme-text-tertiary">{hint}</span>}
+    <div className={clsx('mt-0.5 text-xs', toneTextClass('degraded'))}>
+      CNPG status says primary <span className="font-mono">{conflict.status}</span>; the Pod labelled primary is{' '}
+      <span className="font-mono">{conflict.labelled}</span>. Status may be stale, or a failover is under way.
     </div>
   )
 }
-
-export function RefLink({ refTo, onNavigate, children, mono }: { refTo: CNPGRef; onNavigate?: CNPGNavigate; children?: ReactNode; mono?: boolean }) {
-  const label = children ?? refTo.name
-  if (!onNavigate) return <span className={clsx(mono && 'font-mono')}>{label}</span>
-  return (
-    <button
-      type="button"
-      onClick={() => onNavigate(refTo)}
-      className={clsx('text-accent-text hover:underline text-left break-all', mono && 'font-mono')}
-    >
-      {label}
-    </button>
-  )
-}
-
-const PROBLEM_VARIANT: Record<CNPGProblem['severity'], 'error' | 'warning' | 'info'> = {
-  critical: 'error',
-  warning: 'warning',
-  posture: 'info',
-}
-
-export function ProblemCallout({
-  problem,
-  more,
-  onNavigate,
-  action,
-  subjectIsSelf,
-}: {
-  problem: CNPGProblem
-  more?: ReactNode
-  onNavigate?: CNPGNavigate
-  action?: ReactNode
-  /** The callout sits on the subject's own page, so linking to it would loop. */
-  subjectIsSelf?: boolean
-}) {
-  const aboutChild = !subjectIsSelf && problem.subject.kind !== 'Cluster'
-  return (
-    <AlertBanner variant={PROBLEM_VARIANT[problem.severity]} title={problem.title} message={problem.detail}>
-      <div className="mt-1.5 flex flex-wrap items-center gap-x-3 gap-y-1 text-xs text-theme-text-tertiary">
-        {aboutChild && (
-          <span>
-            {problem.subject.kind}{' '}
-            <RefLink refTo={problem.subject} onNavigate={onNavigate} mono />
-          </span>
-        )}
-        <span>{problem.source === 'audit' ? 'Radar check' : 'Radar issue'}</span>
-        {action}
-        {more}
-      </div>
-    </AlertBanner>
-  )
-}
-
-export function ToneDot({ tone }: { tone: HealthLevel }) {
-  return <StatusDot tone={tone} size="sm" />
-}

package/src/components/cnpg/problems.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceProblem } from '../problems'
+import type { CNPGProblem, CNPGProblemCategory } from './workspace'
+
+export const CNPG_PROBLEM_TONE: Record<CNPGProblem['severity'], WorkspaceProblem['tone']> = {
+  critical: 'unhealthy',
+  warning: 'degraded',
+  posture: 'neutral',
+}
+
+export function cnpgProblemForPresentation(problem: CNPGProblem): WorkspaceProblem<CNPGProblemCategory> {
+  return { ...problem, tone: CNPG_PROBLEM_TONE[problem.severity] }
+}

package/src/components/cnpg/relations.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, it } from 'vitest'
 import {
+  cnpgScheduleDestinationBlocker,
+  cnpgArchiveMatchesCluster,
   appliedFact,
   backupDestination,
   backupsForScheduledBackup,
   clustersUsingCatalog,
   databaseForDeclaration,
-  gitopsSourceOf,
   inferredObjectStoreHealth,
   isBackupFromSchedule,
   issuesForObject,
@@ -16,6 +17,23 @@ import {
   scheduledBackupOf,
   usersOfObjectStore,
 } from './relations'
+
+it('recognizes archive origin aliases without merging distinct paths', () => {
+  const cluster = { metadata: { name: 'pg' }, spec: { backup: { barmanObjectStore: { destinationPath: 's3://bucket/path', endpointURL: 'https://storage.example' } } } }
+  const source = { kind: 'inTree' as const, serverName: 'pg', barmanObjectStore: { destinationPath: 's3://BUCKET/path/', endpointURL: 'https://STORAGE.EXAMPLE:443/' } }
+  expect(cnpgArchiveMatchesCluster(cluster, source)).toBe(true)
+  expect(cnpgArchiveMatchesCluster(cluster, { ...source, barmanObjectStore: { ...source.barmanObjectStore, destinationPath: 's3://bucket/other' } })).toBe(false)
+  expect(cnpgArchiveMatchesCluster(cluster, { ...source, barmanObjectStore: { ...source.barmanObjectStore, endpointURL: 'https://storage.example/prefix' } })).toBe(false)
+})
+
+it('checks the destination for the schedule method and keeps unread targets unknown', () => {
+  const cluster = { apiVersion: 'postgresql.cnpg.io/v1', kind: 'Cluster', metadata: { name: 'payments', namespace: 'pg' }, spec: { backup: { volumeSnapshot: {} }, plugins: [{ name: 'barman-cloud.cloudnative-pg.io', parameters: { barmanObjectName: 'store' } }] } }
+  const schedule = { metadata: { namespace: 'pg' }, spec: { cluster: { name: 'payments' } } }
+  expect(cnpgScheduleDestinationBlocker(schedule, [cluster])).toBe('No barmanObjectStore destination')
+  expect(cnpgScheduleDestinationBlocker(schedule, [])).toBeNull()
+  expect(cnpgScheduleDestinationBlocker({ ...schedule, spec: { ...schedule.spec, method: 'volumeSnapshot' } }, [cluster])).toBeNull()
+  expect(cnpgScheduleDestinationBlocker({ ...schedule, spec: { ...schedule.spec, method: 'plugin', pluginConfiguration: { name: 'barman-cloud.cloudnative-pg.io' } } }, [cluster])).toBeNull()
+})
 import { CNPG_WORKSPACE_KEYS, type CNPGWorkspaceIssue, type CNPGWorkspaceResponse } from './workspace'
 
 const PG = 'postgresql.cnpg.io/v1'
@@ -104,9 +122,10 @@ describe('scheduledBackupOf / backupsForScheduledBackup', () => {
 describe('objectStoreForBackup / backupDestination', () => {
   const clusters = [pluginCluster('main', 'store-a')]
 
-  it('prefers the store the backup recorded', () => {
+  it('ignores the Backup parameter and infers the store from the current Cluster', () => {
     const b = backup('b', { spec: { method: 'plugin', pluginConfiguration: { name: PLUGIN, parameters: { barmanObjectName: 'store-b' } } } })
-    expect(objectStoreForBackup(b, clusters)).toEqual({ name: 'store-b', inferred: false })
+    expect(objectStoreForBackup(b, clusters)).toEqual({ name: 'store-a', inferred: true })
+    expect(backupDestination(b, clusters)).toEqual({ type: 'objectStore', name: 'store-a', inferred: true })
   })
 
   it("marks a store taken from the Cluster's current plugin as inferred", () => {
@@ -115,6 +134,14 @@ describe('objectStoreForBackup / backupDestination', () => {
     expect(backupDestination(b, clusters)).toEqual({ type: 'objectStore', name: 'store-a', inferred: true })
   })
 
+  it('cannot resolve a Backup parameter without a configured, readable target Cluster', () => {
+    const b = backup('b', { spec: { method: 'plugin', pluginConfiguration: { name: PLUGIN, parameters: { barmanObjectName: 'store-b' } } } })
+    for (const targets of [[], [cluster('main')], [pluginCluster('other', 'store-a')], [{ ...pluginCluster('main', 'store-a'), metadata: { name: 'main', namespace: 'other' } }], [cluster('main', 'pg', { plugins: [{ name: PLUGIN, enabled: false, parameters: { barmanObjectName: 'store-a' } }] })]]) {
+      expect(objectStoreForBackup(b, targets)).toBeNull()
+      expect(backupDestination(b, targets)).toEqual({ type: 'unknown' })
+    }
+  })
+
   it('checks plugin identity before reading barmanObjectName', () => {
     const other = backup('b', { spec: { method: 'plugin', pluginConfiguration: { name: 'other.example.com', parameters: { barmanObjectName: 'store-b' } } } })
     expect(objectStoreForBackup(other, clusters)).toBeNull()
@@ -129,6 +156,23 @@ describe('objectStoreForBackup / backupDestination', () => {
   })
 })
 
+describe('barman-cloud schedule destinations', () => {
+  const schedule = { apiVersion: PG, kind: 'ScheduledBackup', metadata: { name: 'nightly', namespace: 'pg' }, spec: { cluster: { name: 'main' }, method: 'plugin', pluginConfiguration: { name: PLUGIN, parameters: { barmanObjectName: 'schedule-store', serverName: 'schedule-server' } } } }
+
+  it('blocks a schedule override when the Cluster plugin has no destination', () => {
+    const target = cluster('main', 'pg', { plugins: [{ name: PLUGIN }] })
+    expect(cnpgScheduleDestinationBlocker(schedule, [target])).toBe('No backup destination')
+    expect(objectStoreForBackup(schedule, [target])).toBeNull()
+  })
+
+  it('uses the configured Cluster destination despite a conflicting schedule override', () => {
+    const target = pluginCluster('main', 'cluster-store')
+    expect(cnpgScheduleDestinationBlocker(schedule, [target])).toBeNull()
+    expect(objectStoreForBackup(schedule, [target])).toEqual({ name: 'cluster-store', inferred: true })
+    expect(cnpgScheduleDestinationBlocker(schedule, [cluster('main', 'pg', { plugins: [{ name: PLUGIN, enabled: false, parameters: { barmanObjectName: 'cluster-store' } }] })])).toBe('No backup destination')
+  })
+})
+
 describe('ObjectStore users and inferred health', () => {
   const store = {
     apiVersion: BARMAN,
@@ -254,16 +298,6 @@ describe('declarations', () => {
     expect(missingManagedRole({ status: { message: 'connection refused' } }, cluster('main'))).toBeNull()
   })
 
-  it('reads the GitOps owner labels', () => {
-    expect(gitopsSourceOf({ metadata: { labels: { 'argocd.argoproj.io/instance': 'app' } } })).toEqual({ tool: 'argocd', name: 'app' })
-    expect(gitopsSourceOf({ metadata: { labels: { 'kustomize.toolkit.fluxcd.io/name': 'k', 'kustomize.toolkit.fluxcd.io/namespace': 'flux' } } })).toEqual({
-      tool: 'flux',
-      name: 'k',
-      namespace: 'flux',
-    })
-    expect(gitopsSourceOf({ metadata: {} })).toBeNull()
-  })
-
   const decl = (kind: string, name: string, clusterName: string, dbname: string, ns = 'pg') => ({
     apiVersion: PG,
     kind,
@@ -302,3 +336,19 @@ describe('relationUnavailable', () => {
     expect(relationUnavailable(null, 'backups', 'pg', 'Backups')).toBe('Backups could not be read')
   })
 })
+
+it('does not apply declaration results from an earlier spec', () => {
+  for (const applied of [true, false]) {
+    expect(appliedFact({ metadata: { generation: 3 }, status: { applied, observedGeneration: 2 } })).toEqual({ text: 'Pending · awaiting the operator for the current spec', tone: 'unknown' })
+  }
+  expect(appliedFact({ metadata: { generation: 3 }, status: { applied: true, observedGeneration: 3 } }).tone).toBe('healthy')
+})
+
+
+it('never infers a plugin archive from a replacement Cluster', () => {
+ const target = { ...pluginCluster('main', 'new-store'), metadata: { name: 'main', namespace: 'pg', uid: 'new', creationTimestamp: '2026-10-01T00:00:00Z' } }
+ for (const status of [{ pluginMetadata: { clusterUID: 'old' } }, { startedAt: '2026-09-30T00:00:00Z' }]) {
+  const old = backup('old', { spec: { method: 'plugin', pluginConfiguration: { name: PLUGIN } }, status })
+  expect(objectStoreForBackup(old, [target])).toBeNull()
+ }
+})