@skyhook-io/k8s-ui 1.18.2 → 1.20.0

package/src/components/resources/resource-utils-kueue-admission.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { kueueAdmissionStateHint, kueueAdmissionStateLabel, kueueAdmissionStatePresentation } from './resource-utils-kueue'
+
+const vector = JSON.parse(readFileSync(fileURLToPath(new URL('../../../../../pkg/schedulinginsight/testdata/kueue_admission_codes.json', import.meta.url)), 'utf8'))
+
+describe('Kueue admission-state presentation', () => {
+  it('has a label for every code the server can send', () => {
+    for (const code of vector.codes as string[]) expect(kueueAdmissionStateLabel(code), code).not.toBe(code)
+  })
+
+  it('has a tone for every attention class and stays neutral for stale or unknown classes', () => {
+    for (const attention of vector.attention as string[]) expect(kueueAdmissionStatePresentation({ state: 'insufficient_quota', attention }).severity).toBeTruthy()
+    expect(kueueAdmissionStatePresentation({ state: 'local_queue_missing', attention: 'action_needed' }).severity).toBe('alert')
+    expect(kueueAdmissionStatePresentation({ state: 'local_queue_missing', attention: 'action_needed', stale: true }).severity).toBe('neutral')
+    expect(kueueAdmissionStatePresentation({ state: 'a_future_code', attention: 'a_future_class' })).toEqual({ label: 'a_future_code', severity: 'neutral' })
+  })
+
+  it('bounds flavor claims to the attempted flavors and keeps required resource requests intact', () => {
+    expect(kueueAdmissionStateLabel('no_matching_flavor')).toContain('flavors tried')
+    const hint = kueueAdmissionStateHint({ state: 'resource_unavailable', attention: 'action_needed' })
+    expect(hint).toContain('If the request is required, use a queue that offers it')
+    expect(hint).toContain('Remove it only if unintended')
+  })
+})

package/src/components/resources/resource-utils-kueue.test.ts

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { isKueueWorkloadEligibleForPendingPosition } from './resource-utils-kueue'
+
+const vectors = JSON.parse(readFileSync(fileURLToPath(new URL('../../../../../pkg/schedulinginsight/testdata/kueue_awaiting_admission.json', import.meta.url)), 'utf8'))
+
+describe('isKueueWorkloadEligibleForPendingPosition', () => {
+  it('has cases', () => expect(vectors.cases.length).toBeGreaterThan(0))
+  for (const testCase of vectors.cases) {
+    it(`matches Go: ${testCase.name}`, () => {
+      expect(isKueueWorkloadEligibleForPendingPosition(testCase.workload)).toBe(testCase.awaiting)
+    })
+  }
+})

package/src/components/resources/resource-utils-kueue.ts

@@ -2,6 +2,7 @@
 
 import type { BadgeSeverity } from '../ui/Badge'
 import type { StatusBadge } from './resource-utils'
+import type { KueueAdmissionState } from '../../types/scheduling'
 import { healthColors } from './resource-utils'
 
 const failedFinishedReasons = new Set(['Failed', 'FailedToStart', 'OutOfSync', 'OwnerNotFound'])
@@ -41,12 +42,34 @@ export function getKueueQueueCondition(resource: any): any {
   return findCondition(resource, 'Active')
 }
 
-function queueConditionStatus(resource: any): StatusBadge {
+/**
+ * The queue reports an intentional stop and nothing else. Kueue names only the
+ * first of a ClusterQueue's inactive causes as the reason, and Stopped always
+ * comes first, so a stopped ClusterQueue that is also missing a flavor or a
+ * check still says Stopped; its message lists every cause. A LocalQueue's
+ * Stopped has the one cause.
+ */
+export function isKueueStopOnly(condition: any, clusterQueue: boolean): boolean {
+  if (condition?.status !== 'False' || condition.reason !== 'Stopped') return false
+  // Only Kueue's multi-cause wording ("is stopped, <more>") counts as more; unfamiliar wording keeps the stop.
+  return !clusterQueue || !/^Can't admit new workloads: is stopped, /.test(condition.message ?? '')
+}
+
+/**
+ * The ClusterQueue's message is Kueue's single-cause stop wording. Stricter
+ * than isKueueStopOnly: lending a stop to another object's tone needs the
+ * positive form, not just the absence of more causes.
+ */
+export function isKueueClusterQueueStopOnlyMessage(condition: any): boolean {
+  return isKueueStopOnly(condition, true) && /^Can't admit new workloads: is stopped\.?$/.test(condition.message ?? '')
+}
+
+function queueConditionStatus(resource: any, clusterQueue: boolean): StatusBadge {
   const active = getKueueQueueCondition(resource)
   if (isKueueConditionStale(active, resource?.metadata?.generation)) {
     return { text: `${active.status === 'True' ? 'Active' : active.reason || 'Unknown'} (stale)`, color: healthColors.unknown, level: 'unknown' }
   }
-  if (active?.status === 'False' && active.reason === 'Stopped') {
+  if (isKueueStopOnly(active, clusterQueue)) {
     return { text: 'Stopped', color: healthColors.neutral, level: 'neutral' }
   }
   return activeConditionStatus(resource)
@@ -124,7 +147,7 @@ function formatWorkloadCount(value: any): string {
 // ============================================================================
 
 export function getClusterQueueStatus(resource: any): StatusBadge {
-  return queueConditionStatus(resource)
+  return queueConditionStatus(resource, true)
 }
 
 export function getClusterQueueCohort(resource: any): string {
@@ -136,6 +159,11 @@ export function getClusterQueuePendingWorkloads(resource: any): string {
   return formatWorkloadCount(resource?.status?.pendingWorkloads)
 }
 
+/** Reserving includes admitted Workloads; the two counts are not additive. */
+export function getKueueQueueReservingWorkloads(resource: any): string {
+  return formatWorkloadCount(resource?.status?.reservingWorkloads)
+}
+
 export function getClusterQueueAdmittedWorkloads(resource: any): string {
   return formatWorkloadCount(resource?.status?.admittedWorkloads)
 }
@@ -155,7 +183,7 @@ export function getClusterQueueFlavors(resource: any): string {
 // ============================================================================
 
 export function getLocalQueueStatus(resource: any): StatusBadge {
-  return queueConditionStatus(resource)
+  return queueConditionStatus(resource, false)
 }
 
 export function getLocalQueueClusterQueue(resource: any): string {
@@ -174,6 +202,10 @@ export function getLocalQueueAdmittedWorkloads(resource: any): string {
 // KUEUE WORKLOAD UTILITIES
 // ============================================================================
 
+// The Workload's most notable native condition, for its status badge. This is
+// not the admission-state classification, which only the server decides
+// (kueue.admission); the two can differ, e.g. an Evicted Workload now blocked
+// by a missing LocalQueue.
 export function getKueueWorkloadStatusCondition(resource: any): any {
   for (const type of ['Finished', 'Evicted', 'Preempted', 'Admitted', 'QuotaReserved']) {
     const condition = findCondition(resource, type)
@@ -200,6 +232,93 @@ export function getKueueWorkloadStatus(resource: any): StatusBadge {
   }
 }
 
+export interface KueueAdmissionStatePresentation {
+  label: string
+  severity: BadgeSeverity
+}
+
+// Presentation only: the server decides every code and its attention class
+// (pkg/schedulinginsight). A code this UI has no label for renders as sent;
+// an attention class it does not know renders in a neutral tone. Stale
+// evidence is always neutral.
+const kueueAdmissionLabels: Record<string, string> = {
+  finished: 'Finished',
+  admitted: 'Admitted',
+  quota_reserved: 'Quota reserved',
+  deactivated: 'Deactivated',
+  deactivated_by_kueue: 'Deactivated by Kueue',
+  deactivation_pending: 'Deactivating',
+  on_hold: 'On hold',
+  no_decision: 'Awaiting evaluation',
+  insufficient_quota: 'Waiting for quota',
+  exceeds_quota: 'Too large for the flavors tried',
+  no_matching_flavor: 'No fit among the flavors tried',
+  resource_unavailable: 'Resource not in the queue',
+  topology_placement_failed: 'Topology placement failed',
+  waiting_for_preemption: 'Waiting for preempted workloads',
+  preemption_gated: 'Preemption gated',
+  admission_gated: 'Admission gated',
+  namespace_not_eligible: 'Namespace not eligible',
+  local_queue_missing: 'LocalQueue missing',
+  local_queue_inactive: 'LocalQueue inactive',
+  cluster_queue_missing: 'ClusterQueue missing',
+  cluster_queue_inactive: 'ClusterQueue inactive',
+  admission_check_rejected: 'Admission check rejected',
+  admission_checks_pending: 'Waiting for admission checks',
+  topology_assignment_pending: 'Waiting for topology assignment',
+  waiting_for_pods_ready: 'Waiting for admitted workloads to start',
+  requeue_backoff: 'Waiting to requeue',
+  dra_resources_unresolved: 'DRA resources unresolved',
+  invalid_workload: 'Invalid workload',
+  unrecognized: 'Unclassified reason',
+  preempted: 'Preempted',
+  pods_ready_timeout: 'Pods not ready in time',
+  evicted: 'Evicted',
+}
+
+const kueueAttentionSeverity: Record<string, BadgeSeverity> = {
+  none: 'neutral',
+  waiting: 'neutral',
+  paused: 'neutral',
+  action_needed: 'alert',
+  unknown: 'info',
+}
+
+// What the reported state usually asks of someone, worded as a suggestion:
+// the classification reads only the Workload, never its queue.
+const kueueAdmissionHints: Record<string, string> = {
+  exceeds_quota: "In its last attempt, Kueue found the requests too large for every flavor it tried. If the queue has no larger flavor, reduce them or ask an admin to raise its quota.",
+  no_matching_flavor: "In its last attempt, no flavor Kueue tried fits the Workload's node selectors, tolerations or topology, or the flavor an earlier slice was admitted to.",
+  resource_unavailable: 'The ClusterQueue has no quota for a resource the job requests. If the request is required, use a queue that offers it or ask an admin to add quota. Remove it only if unintended.',
+  namespace_not_eligible: "The ClusterQueue does not accept this namespace. Use another LocalQueue, or ask an admin.",
+  local_queue_missing: "Check the job's queue name, or ask an admin to create the LocalQueue.",
+  cluster_queue_missing: "The LocalQueue points at a ClusterQueue that doesn't exist or is being deleted. An admin needs to restore it or repoint the LocalQueue.",
+  local_queue_inactive: 'The LocalQueue may be stopped on purpose or misconfigured. Its status says which.',
+  cluster_queue_inactive: 'The ClusterQueue may be stopped on purpose or misconfigured. Its status says which.',
+  admission_check_rejected: 'An admission check rejected the Workload. Kueue usually deactivates it next.',
+  deactivation_pending: 'Kueue is deactivating the Workload. It will not be admitted until reactivated.',
+  deactivated_by_kueue: 'Kueue deactivated this Workload. Fix the cause it reports, then set it active again to retry.',
+  invalid_workload: "Kueue rejects the job's resource requests. Fix them and resubmit.",
+}
+
+export function kueueAdmissionStateHint(admission: Pick<KueueAdmissionState, 'state' | 'attention'>): string | undefined {
+  if (admission.state === 'deactivated' && admission.attention === 'unknown') {
+    return "The Workload doesn't say whether Kueue or a person deactivated it. The earlier eviction it still reports may or may not be why."
+  }
+  return kueueAdmissionHints[admission.state]
+}
+
+export function kueueAdmissionStateLabel(code: string): string {
+  return kueueAdmissionLabels[code] ?? code
+}
+
+export function kueueAdmissionStatePresentation(admission: Pick<KueueAdmissionState, 'state' | 'attention' | 'stale'>): KueueAdmissionStatePresentation {
+  return {
+    label: kueueAdmissionStateLabel(admission.state),
+    severity: admission.stale ? 'neutral' : kueueAttentionSeverity[admission.attention] ?? 'neutral',
+  }
+}
+
 export function getKueueWorkloadQueueName(resource: any): string {
   return resource?.spec?.queueName || '-'
 }
@@ -208,6 +327,20 @@ export function getKueueWorkloadAdmittedBy(resource: any): string {
   return resource?.status?.admission?.clusterQueue || '-'
 }
 
+/**
+ * Whether this Workload snapshot permits a pending-position lookup.
+ * True does not establish that Kueue has observed or queued it. Mirrors Go's
+ * schedulinginsight.KueueWorkloadEligibleForPendingPosition; both read
+ * pkg/schedulinginsight/testdata/kueue_awaiting_admission.json.
+ */
+export function isKueueWorkloadEligibleForPendingPosition(resource: any): boolean {
+  if (resource?.spec?.active === false) return false
+  const conditions: any[] = Array.isArray(resource?.status?.conditions) ? resource.status.conditions : []
+  const byType = new Map<string, any>()
+  for (const condition of conditions) if (condition?.type) byType.set(condition.type, condition)
+  return !['Finished', 'Admitted', 'QuotaReserved'].some(type => byType.get(type)?.status === 'True')
+}
+
 export function getKueueWorkloadPriority(resource: any): string {
   const priority = resource?.spec?.priority
   if (typeof priority === 'number') return String(priority)

package/src/components/resources/resource-utils-opentelemetry.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { readFileSync } from 'node:fs'
-import { renderToString } from 'react-dom/server'
+import { renderToStaticMarkup, renderToString } from 'react-dom/server'
 import { getCollectorPipelines, getOpenTelemetryCollectorStatus, getOpenTelemetryInstrumentationStatus } from './resource-utils-opentelemetry'
 import { getGenericResourceStatus } from './generic-status'
 import { getCellFilterValue } from './resource-utils'
@@ -72,3 +72,11 @@ describe('OpenTelemetry drawer identity and meaning', () => {
     expect(render('other.example/v1', 'Instrumentation', { custom: 'generic-visible' })).toContain('generic-visible')
   })
 })
+
+it('bounds recorded upgrade language rows and labels', () => {
+ const blocked = Object.fromEntries(Array.from({length:30},(_,i)=>[`language-${String(i).padStart(2,'0')}${'x'.repeat(200)}`, 'recorded reason']))
+ const html=renderToStaticMarkup(<ResourceRendererDispatch resource={{kind:'instrumentations',namespace:'test',name:'test'}} data={{apiVersion:'opentelemetry.io/v1alpha1',kind:'Instrumentation',metadata:{name:'test',namespace:'test'},status:{upgradeBlockedVersions:blocked}}} onCopy={()=>{}} copied={null} showCommonSections={false} />)
+ expect(html).toContain('20 more recorded languages in YAML')
+ expect(html).not.toContain('language-10')
+ expect(html).not.toContain('x'.repeat(161))
+})

package/src/components/resources/resource-utils-opentelemetry.ts

@@ -20,7 +20,7 @@ export function getOpenTelemetryCollectorStatus(data: any): StatusBadge {
 export function getOpenTelemetryInstrumentationStatus(data: any): StatusBadge {
   const blocked = Object.keys(data.status?.upgradeBlockedVersions ?? {}).length > 0
   const level = 'neutral'
-  return { text: blocked ? 'Upgrade blocked' : 'Configured', level, color: healthColors[level] }
+  return { text: blocked ? 'Upgrade block recorded' : 'Configured', level, color: healthColors[level] }
 }
 
 export interface CollectorPipeline {

package/src/components/resources/resource-utils-ray.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { getRayCronJobTimeZone, getRayCronJobStatus, getRayServiceStatus } from './resource-utils-ray'
+import { getRayCronJobTimeZone, getRayCronJobStatus, getRayServiceStatus, logsContainer, podLogsUnavailableReason } from './resource-utils-ray'
 import { getCellFilterValue } from './resource-utils'
 
 describe('getRayCronJobTimeZone', () => {
@@ -91,3 +91,44 @@ describe('RayCluster readiness', () => {
     expect(getRayClusterStatus(root({ conditions: [{ type: 'RayClusterProvisioned', status: 'True' }] })).level).toBe('neutral')
   })
 })
+
+describe('logsContainer', () => {
+  const status = (name: string, extra: Record<string, unknown> = {}) => ({ name, ready: false, restartCount: 0, ...extra })
+  it('opens a Pending worker in the regular init container it waits on, past a started native sidecar', () => {
+    expect(logsContainer({ name: 'p', ready: false, phase: 'Pending', containers: ['proxy', 'wait-gcs-ready', 'ray-worker'], containerStatuses: [status('proxy', { init: true, sidecar: true }), status('wait-gcs-ready', { init: true }), status('ray-worker')] }, true)).toBe('wait-gcs-ready')
+  })
+  it('opens the regular init container that failed in a Failed Pod', () => {
+    expect(logsContainer({ name: 'p', ready: false, phase: 'Failed', containers: ['setup', 'ray-worker'], containerStatuses: [status('setup', { init: true }), status('ray-worker')] }, true)).toBe('setup')
+  })
+  it('opens the application of a running Pod, never an unready native sidecar', () => {
+    expect(logsContainer({ name: 'p', ready: false, phase: 'Running', containers: ['proxy', 'ray-worker'], containerStatuses: [status('proxy', { init: true, sidecar: true }), status('ray-worker')] }, true)).toBe('ray-worker')
+  })
+  it('opens the application of a Failed Pod whose init containers finished', () => {
+    expect(logsContainer({ name: 'p', ready: false, phase: 'Failed', containers: ['proxy', 'setup', 'ray-worker'], containerStatuses: [status('proxy', { init: true, sidecar: true }), status('setup', { init: true, ready: true }), status('ray-worker')] }, true)).toBe('ray-worker')
+  })
+  it('leaves the choice to the viewer when init statuses are missing but init containers may exist', () => {
+    expect(logsContainer({ name: 'p', ready: false, phase: 'Running', containers: ['wait-gcs-ready', 'ray-worker'], containerStatuses: [status('ray-worker')] }, true)).toBeUndefined()
+    expect(logsContainer({ name: 'p', ready: true, phase: 'Running', containers: ['ray-head'], containerStatuses: [status('ray-head')] }, true)).toBe('ray-head')
+  })
+  it('leaves the choice to the viewer when no status is reported', () => {
+    expect(logsContainer({ name: 'p', ready: false, containers: ['wait-gcs-ready', 'ray-worker'] }, true)).toBeUndefined()
+  })
+  it('on a Radar that does not mark sidecars, opens the first application container', () => {
+    const onlyWait = { name: 'p', ready: false, phase: 'Pending', containers: ['wait-gcs-ready', 'ray-worker'], containerStatuses: [status('wait-gcs-ready', { init: true }), status('ray-worker')] }
+    expect(logsContainer(onlyWait, false)).toBe('ray-worker')
+    const loneSidecar = { name: 'p', ready: false, phase: 'Pending', containers: ['setup', 'proxy', 'ray-worker'], containerStatuses: [status('setup', { init: true, ready: true }), status('proxy', { init: true }), status('ray-worker')] }
+    expect(logsContainer(loneSidecar, false)).toBe('ray-worker')
+    const failedWithStoppedSidecar = { name: 'p', ready: false, phase: 'Failed', containers: ['proxy', 'setup', 'ray-worker'], containerStatuses: [status('proxy', { init: true }), status('setup', { init: true, ready: true }), status('ray-worker')] }
+    expect(logsContainer(failedWithStoppedSidecar, false)).toBe('ray-worker')
+  })
+})
+
+describe('podLogsUnavailableReason', () => {
+  it('names why a Pod has no output to read yet', () => {
+    expect(podLogsUnavailableReason({ name: 'p', ready: false, containers: ['c'] })).toBe('Not scheduled')
+    expect(podLogsUnavailableReason({ name: 'p', ready: false, nodeName: 'n', containers: ['c'] })).toBe('No status yet')
+    expect(podLogsUnavailableReason({ name: 'p', ready: false, phase: 'Failed', containers: ['c'] })).toBe('Ended before starting')
+    expect(podLogsUnavailableReason({ name: 'p', ready: false, nodeName: 'n', containers: ['proxy', 'c'], containerStatuses: [{ name: 'proxy', init: true, sidecar: true, ready: true, restartCount: 0 }] })).toBe('Waiting to start')
+    expect(podLogsUnavailableReason({ name: 'p', ready: true, containers: ['c'], containerStatuses: [{ name: 'c', ready: true, restartCount: 0 }] })).toBeUndefined()
+  })
+})

package/src/components/resources/resource-utils-ray.ts

@@ -1,5 +1,6 @@
 // KubeRay CRD utility functions (ray.io/v1)
 
+import type { WorkloadPodInfo } from '../../types'
 import type { StatusBadge } from './resource-utils'
 import { healthColors, formatAge } from './resource-utils'
 
@@ -194,3 +195,40 @@ export function rayJobIsLocal(resource: any): boolean {
 export function rayJobSubmissionMode(resource: any): string {
   return resource.spec?.submissionMode || 'K8sJobMode'
 }
+
+/** The KubeRay RayCluster Radar reads Pods for: `ray.io/v1`, or group `ray.io` before the object loads. */
+export function isKubeRayClusterIdentity(group: string | undefined, apiVersion: string | undefined): boolean {
+  return apiVersion ? apiVersion === 'ray.io/v1' : group === 'ray.io'
+}
+
+/** Why a Pod has no container output to read yet, or undefined when it may. */
+export function podLogsUnavailableReason(pod: WorkloadPodInfo): string | undefined {
+  const statuses = pod.containerStatuses ?? []
+  // A native sidecar's status alone doesn't mean the Pod's own containers have one.
+  if (statuses.some(status => !status.sidecar)) return undefined
+  if (pod.phase === 'Failed' || pod.phase === 'Succeeded') return 'Ended before starting'
+  if (statuses.length) return 'Waiting to start'
+  return pod.nodeName ? 'No status yet' : 'Not scheduled'
+}
+
+// The container a Pod's logs open on. Container lists put init containers
+// first and only reported statuses say which those are, so with no statuses
+// the viewer keeps its own default. A regular init container that isn't done
+// while the Pod is Pending is what it waits on (a worker waiting for the head
+// sits in KubeRay's wait-gcs-ready), though it may not have started yet; in a
+// Failed Pod it is what failed, or what never ran if the Pod was evicted
+// first. Native sidecars never finish, so they are never that container.
+// Without sidecar marks (an older Radar) an unready init container can't be
+// told from a sidecar, so the first application container opens instead.
+export function logsContainer(pod: WorkloadPodInfo, sidecarsMarked: boolean): string | undefined {
+  const statuses = pod.containerStatuses ?? []
+  if (!statuses.length) return undefined
+  const init = new Set(statuses.filter(status => status.init).map(status => status.name))
+  // Init statuses missing while there are more containers than reported
+  // application statuses: which names are init containers isn't known.
+  if (!init.size && pod.containers.length > statuses.length) return undefined
+  const blocking = sidecarsMarked && (pod.phase === 'Pending' || pod.phase === 'Failed')
+    ? pod.containers.find(name => statuses.some(status => status.init && !status.sidecar && status.name === name && !status.ready))
+    : undefined
+  return blocking ?? pod.containers.find(name => !init.has(name))
+}

package/src/components/resources/resource-utils-strimzi.test.tsx

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest'
+import { renderToStaticMarkup } from 'react-dom/server'
+import cases from '../../../../../testdata/strimzi/connector-status.json'
+import { getGenericResourceStatus } from './generic-status'
+import { OperationalIssuesShownContext } from '../ui/drawer-components'
+import { getStrimziConnectorStatus, getStrimziConnectorColumnValue } from './resource-utils-strimzi'
+import { StrimziConnectorRenderer } from './renderers/StrimziConnectorRenderer'
+
+describe('Strimzi snapshot parity with canonical Issues', () => {
+  for (const tc of cases) it(tc.name, () => {
+    const status = getStrimziConnectorStatus(tc.resource)
+    expect(status.text).toBe(tc.text)
+    expect(() => renderToStaticMarkup(<StrimziConnectorRenderer data={tc.resource} />)).not.toThrow()
+    expect(getGenericResourceStatus(tc.resource)?.text).toBe(tc.text)
+    expect(status.level === 'degraded').toBe(tc.issue)
+    expect(status.level === 'healthy').toBe(tc.recovered)
+  })
+  it('shows desired and reported facts without config or traces', () => {
+    const data = structuredClone(cases[1].resource) as any
+    data.spec.config = { password: 'private-configuration' }
+    data.status.conditions[0].message = 'condition-trace-sentinel'
+    data.metadata.labels = { 'strimzi.io/cluster': 'connect-workers' }
+    const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+    for (const text of ['Tasks failed', 'Desired state', 'running (default)', 'Maximum tasks', 'RUNNING', 'FAILED', 'worker:8083', 'connect-workers', 'YAML']) expect(html).toContain(text)
+    expect(html).not.toContain('private-configuration')
+    expect(html).not.toContain('private-trace')
+    expect(html).not.toContain('condition-trace-sentinel')
+    expect(html).toContain('Strimzi condition message withheld')
+    expect(html).toContain('status.conditions in YAML')
+  })
+  it('bounds large previews and makes omitted tasks explicit', () => {
+    const data = structuredClone(cases[0].resource) as any
+    data.status.connectorStatus.tasks = Array.from({length: 150}, (_, id) => ({id,state:'RUNNING',worker_id:`worker-${id}`}))
+    const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+    expect(html).toContain('Reported tasks (150)')
+    expect(html).toContain('Show 100 tasks')
+    expect(html).toContain('limited to 100 of 150')
+    expect(html).not.toContain('worker-149')
+  })
+})
+
+it('respects v1beta2 pause and native automatic restart defaults', () => {
+  const data = structuredClone(cases[0].resource) as any
+  data.apiVersion = 'kafka.strimzi.io/v1beta2'
+  data.spec.pause = true
+  data.spec.autoRestart = {}
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html).toContain('paused (spec.pause)')
+  expect(html).toContain('Yes (default)')
+  expect(html).toContain('Unlimited (default)')
+})
+it('qualifies historical evidence independently from badge wording', () => {
+  const data = structuredClone(cases[1].resource) as any
+  data.status.observedGeneration = 1
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html).toContain('Historical or unassessed status')
+  expect(getStrimziConnectorStatus(data).snapshotCurrent).toBe(false)
+})
+
+it('does not render structured runtime values as React children', () => {
+  const data = structuredClone(cases[0].resource) as any
+  data.status.connectorStatus = {connector:{state:{bad:true},worker_id:[]},tasks:[{id:{bad:true},state:[],worker_id:{bad:true}}]}
+  data.status.conditions = {bad:true}
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html).toContain('Not reported')
+  expect(html).not.toContain('[object Object]')
+})
+
+
+it('shows failure guidance only when canonical Issues are not displayed', () => {
+  const data = structuredClone(cases[1].resource)
+  const render = (shown: boolean) => renderToStaticMarkup(<OperationalIssuesShownContext.Provider value={shown}><StrimziConnectorRenderer data={data} /></OperationalIssuesShownContext.Provider>)
+  expect(render(false)).toContain('Strimzi reports a failure in this operator snapshot')
+  expect(render(true)).not.toContain('Strimzi reports a failure in this operator snapshot')
+  data.status.observedGeneration = 0
+  expect(render(false)).not.toContain('Strimzi reports a failure in this operator snapshot')
+})
+
+it('omits withheld-message guidance when no condition message is present', () => {
+  const data = structuredClone(cases[0].resource)
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html).not.toContain('Strimzi condition message withheld')
+})
+
+it('does not suggest a restart allowance when automatic restart is disabled', () => {
+  const data = structuredClone(cases[0].resource) as any
+  data.spec.autoRestart = { enabled: false, maxRestarts: 5 }
+  data.status.autoRestart = { count: 2 }
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html).toContain('Automatic Restart')
+  expect(html).toContain('Reported restarts')
+  expect(html).not.toContain('Maximum restarts')
+  expect(html).not.toContain('Unlimited')
+})
+
+it('uses the same unset maximum-task text in list and detail', () => {
+  const data = structuredClone(cases[0].resource) as any
+  delete data.spec.tasksMax
+  expect(getStrimziConnectorColumnValue(data, 'connectorTasks')).toBe('1 / Not specified')
+  expect(renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)).toContain('Not specified')
+})
+
+it('prioritizes failed and other non-running tasks in the bounded preview', () => {
+  const data = structuredClone(cases[0].resource) as any
+  data.status.connectorStatus.tasks = [
+    ...Array.from({ length: 7 }, (_, id) => ({ id, state: 'RUNNING', worker_id: `running-${id}` })),
+    { id: 7, state: 'RESTARTING', worker_id: 'restarting-worker' },
+    { id: 8, state: 'UNASSIGNED', worker_id: 'unassigned-worker' },
+    { id: 9, state: 'FAILED', worker_id: 'failed-worker' },
+  ]
+  const html = renderToStaticMarkup(<StrimziConnectorRenderer data={data} />)
+  expect(html.indexOf('failed-worker')).toBeLessThan(html.indexOf('restarting-worker'))
+  expect(html.indexOf('restarting-worker')).toBeLessThan(html.indexOf('unassigned-worker'))
+  expect(html.indexOf('unassigned-worker')).toBeLessThan(html.indexOf('running-0'))
+  expect(html).not.toContain('running-2')
+  expect(html).toContain('Show 10 tasks')
+  expect(data.status.connectorStatus.tasks[0].worker_id).toBe('running-0')
+})

package/src/components/resources/resource-utils-strimzi.ts

@@ -0,0 +1,35 @@
+import { isApiGroup } from './resource-utils-cnpg'
+import { healthColors, type StatusBadge } from './resource-utils'
+
+// Generation agreement permits assessment; it does not establish live runtime freshness.
+export function getStrimziConnectorStatus(data: any): StatusBadge & { snapshotCurrent: boolean } {
+  const badge = (text: string, level: StatusBadge['level'], snapshotCurrent = false) => ({ text, level, color: healthColors[level], snapshotCurrent })
+  if (data.metadata?.deletionTimestamp) return badge('Terminating', 'neutral')
+  if (data.metadata?.annotations?.['strimzi.io/pause-reconciliation']?.toLowerCase() === 'true') return badge('Reconciliation paused', 'neutral')
+  const observed = data.status?.observedGeneration
+  if (!Number.isInteger(observed) || observed <= 0) return badge('Status unknown', 'unknown')
+  if (observed !== data.metadata?.generation) return badge('Status stale', 'unknown')
+  const conditions = Array.isArray(data.status?.conditions) ? data.status.conditions : []
+  if (conditions.some((c: any) => c?.type === 'ReconciliationPaused' && c.status === 'True')) return badge('Reconciliation paused', 'neutral')
+  const state = data.status?.connectorStatus?.connector?.state
+  const tasks = Array.isArray(data.status?.connectorStatus?.tasks) ? data.status.connectorStatus.tasks : []
+  if (state === 'FAILED') return badge('Connector failed', 'degraded', true)
+  if (tasks.some((t: any) => t?.state === 'FAILED')) return badge('Tasks failed', 'degraded', true)
+  if (conditions.some((c: any) => c?.type === 'NotReady' && c.status === 'True')) return badge('Not ready', 'degraded', true)
+  if (conditions.every((c: any) => c && typeof c === 'object' && !Array.isArray(c)) && conditions.some((c: any) => c.type === 'Ready' && c.status === 'True') && state === 'RUNNING' && tasks.length > 0 && tasks.every((t: any) => t?.state === 'RUNNING')) return badge('Running', 'healthy', true)
+  if (state === 'PAUSED' || state === 'STOPPED') return badge(state === 'PAUSED' ? 'Paused' : 'Stopped', 'neutral', true)
+  if (state === 'RESTARTING' || state === 'UNASSIGNED') return badge(state === 'RESTARTING' ? 'Restarting' : 'Unassigned', 'unknown', true)
+  if (tasks.some((t: any) => t?.state === 'RESTARTING')) return badge('Tasks restarting', 'unknown', true)
+  return badge('Runtime unknown', 'unknown', true)
+}
+
+export function getStrimziConnectorColumnValue(data: any, column: string): string | undefined {
+  if (data.kind !== 'KafkaConnector' || !isApiGroup(data.apiVersion, 'kafka.strimzi.io')) return undefined
+  switch (column) {
+    case 'status': return getStrimziConnectorStatus(data).text
+    case 'connectCluster': return data.metadata?.labels?.['strimzi.io/cluster'] ?? ''
+    case 'connectorClass': return data.spec?.class ?? ''
+    case 'connectorTasks': return `${Array.isArray(data.status?.connectorStatus?.tasks) ? data.status.connectorStatus.tasks.length : 'Unknown'} / ${data.spec?.tasksMax ?? 'Not specified'}`
+    default: return undefined
+  }
+}

package/src/components/resources/resource-utils.ts

@@ -1,3 +1,5 @@
+import { getCRDColumnValue } from './resource-utils-crd'
+import { getStrimziConnectorColumnValue } from './resource-utils-strimzi'
 import { getOpenTelemetryColumnValue } from './resource-utils-opentelemetry'
 import { getFlaggerColumnValue } from './resource-utils-flagger'
 // Utility functions for resource display in tables
@@ -207,6 +209,22 @@ function podUnschedulable(pod: any): boolean {
   )
 }
 
+// A non-empty spec.schedulingGates means a controller is deliberately holding the
+// pod in Pending (Kueue admission, topology assignment, a custom gate). Mirrors the
+// backend health.PodHasSchedulingGates — keep the two in lockstep (the cross-language
+// golden fixture pins it). The spec field is authoritative and is kept in the summary
+// list payload, so this reads it directly rather than racing the scheduler's
+// PodScheduled=SchedulingGated condition (which lags gate changes in both directions).
+function podSchedulingGated(pod: any): boolean {
+  return (pod?.spec?.schedulingGates || []).length > 0
+}
+
+function schedulingGateNames(pod: any): string[] {
+  return (pod?.spec?.schedulingGates || [])
+    .map((g: any) => g?.name)
+    .filter((n: any): n is string => typeof n === 'string' && n.length > 0)
+}
+
 // A container that has terminated successfully (exit 0) is done, not "not ready".
 // A completing Job pod (Running phase, container Completed, Ready=false) must not
 // read as degraded just because ready<total — this mirrors ClassifyPodHealth, so
@@ -427,6 +445,12 @@ export function getPodStatus(pod: any): StatusBadge {
     case 'Succeeded':
       return { text: 'Completed', color: healthColors.neutral, level: 'neutral' }
     case 'Pending':
+      // A scheduling gate deliberately holds the pod in Pending; it's an
+      // intentional state, not an age-based problem, so it reads neutral and never
+      // ages into a warning. Checked before the unschedulable/age branches.
+      if (podSchedulingGated(pod)) {
+        return { text: 'Scheduling gated', color: healthColors.neutral, level: 'neutral' }
+      }
       // Unschedulable = the scheduler tried and failed to place this pod; the
       // backend flags it immediately (severity ramps with duration), so the badge
       // does too. Plain Pending (not yet placed) keeps the young-grace window.
@@ -577,7 +601,22 @@ export function getPodPhaseDisplay(pod: any): PodPhaseDisplay {
     }
     case 'Succeeded':
       return { phase, text: 'Completed', level: 'neutral' }
-    case 'Pending':
+    case 'Pending': {
+      // A scheduling gate deliberately holds the pod in Pending; surface it as a
+      // calm, explained state (with the gate name) rather than a bare Pending or an
+      // age-based warning. Checked before the unschedulable/age branches.
+      if (podSchedulingGated(pod)) {
+        const gates = schedulingGateNames(pod)
+        return {
+          phase,
+          text: `${phase} — Scheduling gated`,
+          level: 'neutral',
+          hint:
+            gates.length > 0
+              ? `Held by scheduling gate(s): ${gates.join(', ')}. A controller is intentionally blocking scheduling until a condition is met.`
+              : 'A controller is intentionally blocking scheduling until a condition is met.',
+        }
+      }
       // Unschedulable = the scheduler tried and failed; surface it immediately
       // (the backend does, with severity ramping by duration). Plain Pending
       // (not yet placed) keeps the young-grace window.
@@ -598,6 +637,7 @@ export function getPodPhaseDisplay(pod: any): PodPhaseDisplay {
         }
       }
       return { phase, text: 'Pending', level: 'neutral' }
+    }
     case 'Failed':
       return { phase, text: 'Failed', level: 'unhealthy' }
     default:
@@ -2464,10 +2504,14 @@ function parseColumnFilterPair(
 
 export function getCellFilterValue(resource: any, column: string, kind: string): string {
   try {
+  const connectorValue = getStrimziConnectorColumnValue(resource, column)
+  if (connectorValue !== undefined) return connectorValue
   const otelValue = getOpenTelemetryColumnValue(resource, column)
   if (otelValue !== undefined) return otelValue
   const flaggerValue = getFlaggerColumnValue(resource, column)
   if (flaggerValue !== undefined) return flaggerValue
+  const crdValue = getCRDColumnValue(resource, column)
+  if (crdValue !== undefined) return crdValue
   const kindLower = kind.toLowerCase()
 
   switch (column) {