@skyhook-io/k8s-ui 1.13.3 → 1.14.0

package/src/components/resources/resource-utils-gpu-ecosystem.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getClusterQueueCohort,
+  getKueueWorkloadPriority,
+  getKueueWorkloadStatus,
+} from './resource-utils-kueue'
+import { getRayClusterStatus, getRayJobStatus, getRayServiceStatus } from './resource-utils-ray'
+import {
+  getInferenceServiceStatus,
+  getLLMInferenceServiceReplicas,
+  getServingRuntimeStatus,
+} from './resource-utils-kserve'
+import {
+  getInferenceObjectivePriority,
+  getInferenceObjectiveStatus,
+  getInferencePoolStatus,
+} from './resource-utils-inference-gateway'
+import { getJobSetStatus, getLeaderWorkerSetStatus } from './resource-utils-jobset-lws'
+import { getVolcanoJobStatus, getVolcanoPodGroupStatus } from './resource-utils-volcano'
+import { getKaiPodGroupStatus, getKaiQueuePriority, getKaiQueueQuota, getKaiQueueStatus } from './resource-utils-kai'
+import { getKaitoWorkspaceStatus, getRAGEngineStatus } from './resource-utils-kaito'
+import { getNIMCacheStatus, getNIMServiceReplicas } from './resource-utils-nim'
+import { getAMDDeviceConfigStatus } from './resource-utils-amd-gpu'
+import { getTrainingJobReplicas, getTrainJobStatus, trainingJobStatus } from './resource-utils-kubeflow-training'
+
+describe('GPU ecosystem API contracts', () => {
+  it('reads current Kueue v1beta2 fields and condition precedence', () => {
+    const workload = {
+      spec: { priorityClassRef: { name: 'critical' } },
+      status: { conditions: [
+        { type: 'Admitted', status: 'True' },
+        { type: 'Evicted', status: 'True' },
+      ] },
+    }
+    expect(getClusterQueueCohort({ spec: { cohortName: 'gpu' } })).toBe('gpu')
+    expect(getKueueWorkloadPriority(workload)).toBe('critical')
+    expect(getKueueWorkloadStatus(workload).text).toBe('Evicted')
+  })
+
+  it('distinguishes Kueue terminal failures from successful workloads', () => {
+    for (const reason of ['Failed', 'FailedToStart', 'OutOfSync', 'OwnerNotFound']) {
+      expect(getKueueWorkloadStatus({
+        status: { conditions: [{ type: 'Finished', status: 'True', reason }] },
+      })).toMatchObject({ text: reason, level: 'unhealthy' })
+    }
+
+    for (const reason of ['Succeeded', 'WorkloadSliceReplaced']) {
+      expect(getKueueWorkloadStatus({
+        status: { conditions: [{ type: 'Finished', status: 'True', reason }] },
+      })).toMatchObject({ text: 'Finished', level: 'neutral' })
+    }
+  })
+
+  it('lets KubeRay conditions outrank deprecated state fields', () => {
+    expect(getRayClusterStatus({
+      status: {
+        state: 'ready',
+        conditions: [{ type: 'HeadPodReady', status: 'False', reason: 'HeadUnavailable' }],
+      },
+    }).text).toBe('HeadUnavailable')
+    expect(getRayServiceStatus({
+      status: {
+        serviceStatus: 'Running',
+        conditions: [{ type: 'Ready', status: 'False', reason: 'ServeNotReady' }],
+      },
+    }).text).toBe('ServeNotReady')
+    expect(getRayServiceStatus({
+      spec: { suspend: true },
+      status: { conditions: [{ type: 'Suspending', status: 'True' }] },
+    }).text).toBe('Suspending')
+  })
+
+  it('requires both the KubeRay head and workers before reporting Ready', () => {
+    expect(getRayClusterStatus({
+      status: {
+        conditions: [{ type: 'HeadPodReady', status: 'True' }],
+        availableWorkerReplicas: 1,
+        desiredWorkerReplicas: 2,
+      },
+    }).text).toBe('Workers 1/2')
+    expect(getRayClusterStatus({
+      status: {
+        conditions: [{ type: 'HeadPodReady', status: 'True' }],
+        availableWorkerReplicas: 2,
+        desiredWorkerReplicas: 2,
+      },
+    }).text).toBe('Ready')
+  })
+
+  it('surfaces current KubeRay replica and RayJob deployment failures', () => {
+    expect(getRayClusterStatus({
+      status: {
+        conditions: [{ type: 'RayClusterReplicaFailure', status: 'True', reason: 'FailedCreateWorkerPod' }],
+      },
+    }).text).toBe('FailedCreateWorkerPod')
+    expect(getRayJobStatus({
+      status: { jobStatus: 'PENDING', jobDeploymentStatus: 'ValidationFailed' },
+    }).text).toBe('ValidationFailed')
+    expect(getRayJobStatus({
+      status: { jobStatus: 'RUNNING', jobDeploymentStatus: 'Failed' },
+    }).text).toBe('Failed')
+  })
+
+  it('does not claim KServe runtime health from enabled configuration alone', () => {
+    const enabled = getServingRuntimeStatus({ spec: {} })
+    expect(enabled.text).toBe('Enabled')
+    expect(enabled.level).toBe('neutral')
+  })
+
+  it('presents KServe transition failures as operator-readable status', () => {
+    expect(getInferenceServiceStatus({
+      status: { modelStatus: { transitionStatus: 'BlockedByFailedLoad' } },
+    }).text).toBe('Load failed')
+    expect(getInferenceServiceStatus({
+      status: { modelStatus: { transitionStatus: 'InvalidSpec' } },
+    }).text).toBe('Invalid spec')
+  })
+
+  it('reads the inline replicas field in both served LLMInferenceService versions', () => {
+    expect(getLLMInferenceServiceReplicas({ spec: { replicas: 3 } })).toBe('3')
+  })
+
+  it('understands current llm-d and deployed InferenceObjective conditions', () => {
+    expect(getInferenceObjectiveStatus({
+      status: { conditions: [{ type: 'Ready', status: 'True' }] },
+    }).text).toBe('Accepted')
+    expect(getInferenceObjectiveStatus({
+      status: { conditions: [{ type: 'Accepted', status: 'False', reason: 'InvalidPool' }] },
+    }).text).toBe('InvalidPool')
+    expect(getInferenceObjectiveStatus({ status: { conditions: [] } }).text).toBe('Unknown')
+    expect(getInferenceObjectivePriority({ spec: {} })).toBe('0')
+  })
+
+  it('does not treat the alpha InferencePool sentinel parent as a Gateway', () => {
+    expect(getInferencePoolStatus({
+      status: { parent: [{ parentRef: { kind: 'Status', name: 'default' } }] },
+    }).text).toBe('Not referenced')
+  })
+
+  it('distinguishes pending JobSets from active work', () => {
+    expect(getJobSetStatus({ status: { replicatedJobsStatus: [{ active: 0, ready: 0 }] } }).text).toBe('Pending')
+    expect(getJobSetStatus({ status: { replicatedJobsStatus: [{ active: 1, ready: 0 }] } }).text).toBe('Running')
+  })
+
+  it('surfaces an unavailable LeaderWorkerSet before progress', () => {
+    expect(getLeaderWorkerSetStatus({
+      status: { conditions: [{ type: 'Available', status: 'False', reason: 'PodsNotReady' }] },
+    }).text).toBe('PodsNotReady')
+  })
+
+  it('classifies Volcano terminal and unschedulable states', () => {
+    expect(getVolcanoJobStatus({ status: { state: { phase: 'Failed' } } }).level).toBe('unhealthy')
+    expect(getVolcanoPodGroupStatus({
+      status: { conditions: [{ type: 'Unschedulable', status: 'True' }] },
+    }).text).toBe('Unschedulable')
+  })
+
+  it('reads KAI quota units and scheduling failures', () => {
+    expect(getKaiQueueQuota({
+      spec: { resources: { gpu: { quota: 2 }, cpu: { quota: 500 }, memory: { quota: -1 } } },
+    })).toBe('GPU: 2, CPU: 500m, Mem: unlimited')
+    expect(getKaiQueuePriority({ spec: {} })).toBe('100')
+    expect(getKaiQueueStatus({
+      status: { conditions: [{ type: 'Orphan', status: 'True', reason: 'ParentNotFound' }] },
+    }).text).toBe('ParentNotFound')
+    expect(getKaiPodGroupStatus({
+      status: { schedulingConditions: [{ type: 'UnschedulableOnNodePool', status: 'True' }] },
+    }).text).toBe('Unschedulable')
+  })
+
+  it('uses KAITO v1beta1 state and RAGEngine conditions', () => {
+    expect(getKaitoWorkspaceStatus({
+      status: { state: 'Failed', conditions: [{ type: 'ResourceReady', status: 'True' }] },
+    }).level).toBe('unhealthy')
+    expect(getKaitoWorkspaceStatus({ status: { state: 'Pending' } }).text).toBe('Pending')
+    expect(getRAGEngineStatus({
+      status: { conditions: [{ type: 'ServiceReady', status: 'False', reason: 'DeploymentUnavailable' }] },
+    }).text).toBe('DeploymentUnavailable')
+    expect(getRAGEngineStatus({
+      status: { conditions: [
+        { type: 'ResourceReady', status: 'True' },
+        { type: 'ServiceReady', status: 'True' },
+      ] },
+    }).text).toBe('Ready')
+  })
+
+  it('reads NIM state and scaling bounds', () => {
+    expect(getNIMCacheStatus({ status: { state: 'Failed' } }).level).toBe('unhealthy')
+    expect(getNIMServiceReplicas({
+      spec: { scale: { enabled: true, hpa: { minReplicas: 1, maxReplicas: 4 } } },
+      status: { availableReplicas: 2 },
+    })).toBe('2 (1-4)')
+  })
+
+  it('lets AMD DeviceConfig readiness conditions outrank rollout counts', () => {
+    expect(getAMDDeviceConfigStatus({
+      status: {
+        conditions: [{ type: 'Ready', status: 'False', reason: 'DriverInstallFailed' }],
+        driver: { desiredNumber: 2, availableNumber: 2 },
+        devicePlugin: { desiredNumber: 2, availableNumber: 2 },
+      },
+    }).text).toBe('DriverInstallFailed')
+  })
+
+  it('uses semantic precedence for Kubeflow conditions instead of array order', () => {
+    expect(trainingJobStatus({
+      status: { conditions: [
+        { type: 'Failed', status: 'True' },
+        { type: 'Running', status: 'True' },
+      ] },
+    }).text).toBe('Failed')
+    expect(getTrainJobStatus({
+      spec: { suspend: true },
+      status: { conditions: [] },
+    }).text).toBe('Suspended')
+    expect(getTrainJobStatus({
+      status: { conditions: [{ type: 'Suspended', status: 'False' }] },
+    }).text).toBe('Pending')
+    expect(getTrainJobStatus({
+      status: { jobsStatus: [{ name: 'trainer', active: 1 }] },
+    }).text).toBe('Running')
+    expect(getTrainJobStatus({
+      status: { conditions: [{ type: 'Failed', status: 'True' }] },
+    }).text).toBe('Failed')
+    expect(getTrainJobStatus({
+      status: {
+        conditions: [{ type: 'Complete', status: 'True' }],
+        jobsStatus: [{ name: 'trainer', active: 1 }],
+      },
+    }).text).toBe('Complete')
+    expect(getTrainingJobReplicas({
+      spec: { pytorchReplicaSpecs: { Worker: { replicas: 4 } } },
+      status: { replicaStatuses: { Worker: { active: 1, succeeded: 1, failed: 2 } } },
+    })).toBe('Worker 2/4 (2 failed)')
+  })
+})

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

@@ -22,6 +22,10 @@ describe('hpaStateLabel', () => {
   it('keeps max-bound wording terse for table cells', () => {
     expect(hpaStateLabel('limited_max')).toBe('Maxed')
   })
+
+  it('describes an intentional zero-replica target', () => {
+    expect(hpaStateLabel('scaled_to_zero')).toBe('Scaled to zero')
+  })
 })
 
 function loadCases(): FixtureCase[] {

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

@@ -12,9 +12,10 @@ export function getHPATableState(hpa: any): HPADiagnosisState {
   if (conditionStatus(conditions, 'AbleToScale') === 'False') return 'unable_to_scale'
   const scalingActive = condition(conditions, 'ScalingActive')
   if (scalingActive?.status === 'False') {
-    if (isScalingDisabled(scalingActive)) return 'disabled'
-    return 'metrics_unavailable'
+    if (!isScalingDisabled(scalingActive)) return 'metrics_unavailable'
   }
+  if (conditionStatus(conditions, 'ScaledToZero') === 'True' && min === 0 && desired === 0) return 'scaled_to_zero'
+  if (scalingActive?.status === 'False' && isScalingDisabled(scalingActive)) return 'disabled'
   if (max > 0 && min === max && current === desired && desired === max) return 'pinned'
   if (isMaxLimited(condition(conditions, 'ScalingLimited'))) return 'limited_max'
 
@@ -31,6 +32,8 @@ export function hpaStateLabel(state: HPADiagnosisState): string {
       return 'Metrics unavailable'
     case 'metrics_incomplete':
       return 'Metrics incomplete'
+    case 'scaled_to_zero':
+      return 'Scaled to zero'
     case 'disabled':
       return 'Disabled'
     case 'pinned':
@@ -66,6 +69,7 @@ export function hpaStateLevel(state: HPADiagnosisState): HealthLevel {
     case 'scaling_down':
       return 'degraded'
     case 'limited_min':
+    case 'scaled_to_zero':
     case 'disabled':
     case 'pinned':
     case 'stabilized':

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

@@ -0,0 +1,119 @@
+// Gateway API Inference Extension CRD utility functions.
+// InferencePool exists in two shapes: v1 (inference.networking.k8s.io) and
+// v1alpha2 (inference.networking.x-k8s.io); accessors handle both.
+
+import type { StatusBadge } from './resource-utils'
+import { healthColors } from './resource-utils'
+
+// ============================================================================
+// INFERENCEPOOL UTILITIES
+// ============================================================================
+
+// v1 serializes status.parents, v1alpha2 serializes status.parent
+function getPoolParents(resource: any): any[] {
+  const status = resource.status
+  if (!status) return []
+  if (Array.isArray(status.parents)) return status.parents
+  if (Array.isArray(status.parent)) return status.parent
+  return []
+}
+
+// v1alpha2 reserves a synthetic parent entry to mean "no gateway references
+// this pool" — seen as parentRef {kind: Status, name: default} or as an
+// empty/missing parentRef. A ref without a name can't be a real Gateway.
+function isDefaultParent(parent: any): boolean {
+  const ref = parent?.parentRef
+  if (!ref?.name) return true
+  return ref.kind === 'Status' && ref.name === 'default'
+}
+
+export function getInferencePoolStatus(resource: any): StatusBadge {
+  const parents = getPoolParents(resource).filter((p: any) => !isDefaultParent(p))
+  if (parents.length === 0) {
+    return { text: 'Not referenced', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  const conditions = parents.flatMap((p: any) => (Array.isArray(p?.conditions) ? p.conditions : []))
+  if (conditions.length === 0) {
+    return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+  }
+
+  const resolvedRefsFailed = conditions.find((c: any) => c?.type === 'ResolvedRefs' && c.status === 'False')
+  if (resolvedRefsFailed) {
+    return { text: resolvedRefsFailed.reason || 'RefsNotResolved', color: healthColors.alert, level: 'alert' }
+  }
+
+  const accepted = conditions.filter((c: any) => c?.type === 'Accepted')
+  const acceptedTrue = accepted.filter((c: any) => c.status === 'True')
+  if (accepted.length > 0 && acceptedTrue.length === accepted.length) {
+    return { text: 'Accepted', color: healthColors.healthy, level: 'healthy' }
+  }
+  if (acceptedTrue.length > 0) {
+    return { text: 'Partially accepted', color: healthColors.degraded, level: 'degraded' }
+  }
+  const notAccepted = accepted.find((c: any) => c.status === 'False')
+  if (notAccepted) {
+    return { text: notAccepted.reason || 'NotAccepted', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getInferencePoolSelector(resource: any): string {
+  const selector = resource.spec?.selector
+  if (!selector || typeof selector !== 'object') return '-'
+  const labels = selector.matchLabels && typeof selector.matchLabels === 'object' ? selector.matchLabels : selector
+  const entries = Object.entries(labels).filter(([, v]) => typeof v === 'string' || typeof v === 'number')
+  if (entries.length === 0) return '-'
+  const parts = entries.map(([k, v]) => `${k}=${v}`)
+  if (parts.length > 2) return `${parts.slice(0, 2).join(', ')} +${parts.length - 2}`
+  return parts.join(', ')
+}
+
+export function getInferencePoolTargetPorts(resource: any): string {
+  const spec = resource.spec
+  if (!spec) return '-'
+  if (Array.isArray(spec.targetPorts)) {
+    const numbers = spec.targetPorts
+      .map((p: any) => p?.number)
+      .filter((n: any) => n !== undefined && n !== null)
+    return numbers.length > 0 ? numbers.join(', ') : '-'
+  }
+  if (spec.targetPortNumber !== undefined && spec.targetPortNumber !== null) {
+    return String(spec.targetPortNumber)
+  }
+  return '-'
+}
+
+export function getInferencePoolExtensionRef(resource: any): string {
+  const ref = resource.spec?.endpointPickerRef || resource.spec?.extensionRef
+  return ref?.name || '-'
+}
+
+// ============================================================================
+// INFERENCEOBJECTIVE UTILITIES
+// ============================================================================
+
+export function getInferenceObjectiveStatus(resource: any): StatusBadge {
+  const conditions = Array.isArray(resource.status?.conditions) ? resource.status.conditions : []
+  const accepted = conditions.find((c: any) => c?.type === 'Accepted')
+    || conditions.find((c: any) => c?.type === 'Ready')
+  if (accepted?.status === 'True') {
+    return { text: 'Accepted', color: healthColors.healthy, level: 'healthy' }
+  }
+  if (accepted?.status === 'False') {
+    return { text: accepted.reason || 'NotAccepted', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getInferenceObjectivePoolRef(resource: any): string {
+  return resource.spec?.poolRef?.name || '-'
+}
+
+// API spec: consumers treat an unset priority as 0
+export function getInferenceObjectivePriority(resource: any): string {
+  const priority = resource.spec?.priority
+  if (priority === undefined || priority === null) return '0'
+  return String(priority)
+}

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

@@ -0,0 +1,117 @@
+// LeaderWorkerSet (leaderworkerset.x-k8s.io/v1) and JobSet (jobset.x-k8s.io/v1alpha2) utility functions
+
+import type { StatusBadge } from './resource-utils'
+import { healthColors } from './resource-utils'
+
+// ============================================================================
+// LEADERWORKERSET UTILITIES
+// ============================================================================
+
+export function getLeaderWorkerSetStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions || []
+
+  const availableCond = conditions.find((c: any) => c.type === 'Available')
+  if (availableCond?.status === 'True') {
+    return { text: 'Available', color: healthColors.healthy, level: 'healthy' }
+  }
+
+  const updateCond = conditions.find((c: any) => c.type === 'UpdateInProgress')
+  if (updateCond?.status === 'True') {
+    return { text: 'Updating', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const progressingCond = conditions.find((c: any) => c.type === 'Progressing')
+  if (progressingCond?.status === 'True') {
+    return { text: 'Progressing', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  if (availableCond?.status === 'False') {
+    return { text: availableCond.reason || 'Unavailable', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getLeaderWorkerSetReplicas(resource: any): string {
+  const replicas = resource.spec?.replicas
+  return replicas !== undefined && replicas !== null ? String(replicas) : '1'
+}
+
+export function getLeaderWorkerSetSize(resource: any): string {
+  const size = resource.spec?.leaderWorkerTemplate?.size
+  return size !== undefined && size !== null ? String(size) : '1'
+}
+
+export function getLeaderWorkerSetReady(resource: any): string {
+  const ready = resource.status?.readyReplicas ?? 0
+  const desired = resource.spec?.replicas ?? 1
+  return `${ready}/${desired}`
+}
+
+export function getLeaderWorkerSetUpdated(resource: any): string {
+  const updated = resource.status?.updatedReplicas
+  return updated !== undefined && updated !== null ? String(updated) : '0'
+}
+
+// ============================================================================
+// JOBSET UTILITIES
+// ============================================================================
+
+export function getJobSetStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions || []
+
+  const failedCond = conditions.find((c: any) => c.type === 'Failed')
+  if (failedCond?.status === 'True') {
+    return { text: failedCond.reason || 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  const completedCond = conditions.find((c: any) => c.type === 'Completed')
+  if (completedCond?.status === 'True') {
+    return { text: 'Completed', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  const suspendedCond = conditions.find((c: any) => c.type === 'Suspended')
+  if (suspendedCond?.status === 'True' || resource.spec?.suspend === true) {
+    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  // Running only when child jobs are actually live — a fresh JobSet carries a
+  // minimal status (no conditions, zeroed counts) before reconciliation.
+  const live = sumReplicatedJobsField(resource, 'active') + sumReplicatedJobsField(resource, 'ready')
+  if (live > 0) {
+    return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+  }
+  if (resource.status) {
+    return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getJobSetReplicatedJobs(resource: any): string {
+  const jobs = resource.spec?.replicatedJobs
+  if (!Array.isArray(jobs) || jobs.length === 0) return '-'
+  return String(jobs.length)
+}
+
+function sumReplicatedJobsField(resource: any, field: string): number {
+  const statuses = resource.status?.replicatedJobsStatus
+  if (!Array.isArray(statuses)) return 0
+  return statuses.reduce((sum: number, s: any) => sum + (s?.[field] ?? 0), 0)
+}
+
+export function getJobSetReadyJobs(resource: any): number {
+  return sumReplicatedJobsField(resource, 'ready')
+}
+
+export function getJobSetSucceededJobs(resource: any): number {
+  return sumReplicatedJobsField(resource, 'succeeded')
+}
+
+export function getJobSetFailedJobs(resource: any): number {
+  return sumReplicatedJobsField(resource, 'failed')
+}
+
+export function getJobSetRestarts(resource: any): number {
+  return resource.status?.restarts ?? 0
+}

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

@@ -0,0 +1,105 @@
+// KAI Scheduler CRD utility functions
+
+import type { StatusBadge } from './resource-utils'
+import { healthColors } from './resource-utils'
+
+// ============================================================================
+// SHARED HELPERS
+// ============================================================================
+
+function summarizeResourceList(list: any): string {
+  if (!list || typeof list !== 'object') return '-'
+  const parts: string[] = []
+  if (list.cpu !== undefined) parts.push(`CPU: ${list.cpu}`)
+  if (list.memory !== undefined) parts.push(`Mem: ${list.memory}`)
+  if (list['nvidia.com/gpu'] !== undefined) parts.push(`GPU: ${list['nvidia.com/gpu']}`)
+  const rest = Object.keys(list).filter((k) => k !== 'cpu' && k !== 'memory' && k !== 'nvidia.com/gpu')
+  if (rest.length > 0) parts.push(`+${rest.length} more`)
+  return parts.length > 0 ? parts.join(', ') : '-'
+}
+
+// KAI quota units: GPU in fractions, CPU in millicpus, memory in megabytes; -1 means unlimited
+function formatKaiQuota(value: any, unit: string): string {
+  if (typeof value !== 'number') return '-'
+  if (value === -1) return 'unlimited'
+  return `${value}${unit}`
+}
+
+// ============================================================================
+// KAI QUEUE UTILITIES (scheduling.run.ai/v2, cluster-scoped)
+// ============================================================================
+
+export function getKaiQueueStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions || []
+  const orphan = conditions.find((condition: any) => condition?.type === 'Orphan' && condition?.status === 'True')
+  if (orphan) {
+    return { text: orphan.reason || 'Orphan', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+  const overQuota = conditions.find((condition: any) => condition?.type === 'OverQuota' && condition?.status === 'True')
+  if (overQuota) {
+    return { text: overQuota.reason || 'Over quota', color: healthColors.degraded, level: 'degraded' }
+  }
+  return { text: 'Configured', color: healthColors.neutral, level: 'neutral' }
+}
+
+export function getKaiQueueParent(resource: any): string {
+  return resource.spec?.parentQueue || '-'
+}
+
+export function getKaiQueuePriority(resource: any): string {
+  const priority = resource.spec?.priority
+  return priority !== undefined && priority !== null ? String(priority) : '100'
+}
+
+export function getKaiQueueQuota(resource: any): string {
+  const resources = resource.spec?.resources
+  if (!resources) return '-'
+  const parts: string[] = []
+  if (typeof resources.gpu?.quota === 'number') parts.push(`GPU: ${formatKaiQuota(resources.gpu.quota, '')}`)
+  if (typeof resources.cpu?.quota === 'number') parts.push(`CPU: ${formatKaiQuota(resources.cpu.quota, 'm')}`)
+  if (typeof resources.memory?.quota === 'number') parts.push(`Mem: ${formatKaiQuota(resources.memory.quota, 'MB')}`)
+  return parts.length > 0 ? parts.join(', ') : '-'
+}
+
+export function getKaiQueueAllocated(resource: any): string {
+  return summarizeResourceList(resource.status?.allocated)
+}
+
+// ============================================================================
+// KAI PODGROUP UTILITIES (scheduling.run.ai/v2alpha2)
+// ============================================================================
+
+export function getKaiPodGroupStatus(resource: any): StatusBadge {
+  const phase = resource.status?.phase
+  if (phase === 'Running') {
+    return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+  }
+  const conditions = resource.status?.conditions || []
+  const schedulingConditions = resource.status?.schedulingConditions || []
+  const unschedulable =
+    conditions.some((c: any) => c.type === 'Unschedulable' && c.status === 'True') ||
+    schedulingConditions.some((c: any) => c.type === 'UnschedulableOnNodePool' && c.status === 'True')
+  if (unschedulable) {
+    return { text: 'Unschedulable', color: healthColors.alert, level: 'alert' }
+  }
+  if (phase === 'Pending' || phase === 'Inqueue' || phase === 'Completed' || phase === 'Succeeded') {
+    return { text: phase, color: healthColors.neutral, level: 'neutral' }
+  }
+  if (phase === 'Failed') {
+    return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+  // OSS KAI components never write status.phase (Run:ai platform does); fall back to pod counts
+  if (!phase && (resource.status?.running || 0) > 0) {
+    return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+  }
+  return { text: phase || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getKaiPodGroupQueue(resource: any): string {
+  return resource.spec?.queue || '-'
+}
+
+export function getKaiPodGroupMinMember(resource: any): string {
+  const min = resource.spec?.minMember
+  return min !== undefined && min !== null ? String(min) : '-'
+}