@skyhook-io/k8s-ui 1.14.9 → 1.14.11

package/src/components/resources/renderers/RayServiceRenderer.tsx

@@ -0,0 +1,114 @@
+import type { ReactNode } from 'react'
+import { Activity, GitBranch } from 'lucide-react'
+import type { ResourceRef } from '../../../types'
+import { Badge, type BadgeSeverity } from '../../ui/Badge'
+import { AlertBanner, ConditionsSection, type ConditionTone, Property, PropertyList, ResourceLink, Section } from '../../ui/drawer-components'
+import { isRayObservationStale, isRayServiceConditionStale } from '../resource-utils-ray'
+
+export interface RayServiceRendererProps {
+  data: any
+  onNavigate?: (ref: ResourceRef) => void
+  runtimeEvidence?: Partial<Record<'active' | 'pending', ReactNode>>
+}
+
+const visibleEntries = 20
+
+export function serveStateSeverity(state?: string): BadgeSeverity {
+  if (state === 'RUNNING' || state === 'HEALTHY') return 'success'
+  if (state === 'DEPLOY_FAILED' || state === 'UNHEALTHY') return 'error'
+  if (['DEPLOYING', 'UPDATING', 'UPSCALING', 'DOWNSCALING', 'DELETING'].includes(state ?? '')) return 'warning'
+  return 'neutral'
+}
+
+function orderedStatuses(statuses: Record<string, any> = {}) {
+  const rank = (status?: string) => {
+    const severity = serveStateSeverity(status)
+    return severity === 'error' ? 0 : severity === 'neutral' ? 1 : severity === 'warning' ? 2 : 3
+  }
+  const entryRank = (entry: any) => Math.min(rank(entry.status), ...Object.values(entry.serveDeploymentStatuses ?? {}).map((deployment: any) => rank(deployment.status)))
+  return Object.entries(statuses).sort(([a, av], [b, bv]) => entryRank(av) - entryRank(bv) || a.localeCompare(b))
+}
+
+export function rayServiceConditionTone(condition: any): ConditionTone {
+  if (!['True', 'False'].includes(condition.status)) return 'unknown'
+  if (condition.type === 'Ready') return condition.status === 'True' ? 'ok' : 'warning'
+  if (['UpgradeInProgress', 'RollbackInProgress', 'Suspending'].includes(condition.type)) return condition.status === 'True' ? 'warning' : 'unknown'
+  return 'unknown'
+}
+
+function NativeState({ name, data }: { name: string; data: any }) {
+  return <>
+    <div className="grid grid-cols-[minmax(0,1fr)_auto] items-start gap-3">
+      <span className="break-words text-sm font-medium text-theme-text-primary">{name}</span>
+      <Badge severity={serveStateSeverity(data.status)} size="sm">{data.status || 'Not reported'}</Badge>
+    </div>
+    {data.message && <p className="mt-1 whitespace-pre-wrap break-words text-sm text-theme-text-secondary">{data.message}</p>}
+  </>
+}
+
+function ServeApplications({ slot }: { slot: any }) {
+  const apps = orderedStatuses(slot.applicationStatuses)
+  return <div className="mt-3 space-y-3">
+    <p className="text-xs text-theme-text-tertiary">Application states are snapshots reported by KubeRay, not a live Serve dashboard query.</p>
+    {apps.length === 0 ? <p className="text-sm text-theme-text-secondary">Application status is not reported for this revision. During a NewCluster upgrade, the active application map can be cleared while its endpoint still serves requests.</p>
+      : apps.slice(0, visibleEntries).map(([name, app]) => {
+        const deployments = orderedStatuses(app.serveDeploymentStatuses)
+        return <div className="card-inner min-w-0" key={name}>
+          <NativeState name={name} data={app} />
+          <div className="mt-3 space-y-2 border-t border-theme-border pt-2">
+            <p className="text-xs text-theme-text-tertiary">Serve deployments{deployments.length > 0 ? ` (${deployments.length})` : ''}</p>
+            {deployments.slice(0, visibleEntries).map(([deployment, state]) => <div className="min-w-0" key={deployment}><NativeState name={deployment} data={state} /></div>)}
+            {deployments.length === 0 && <p className="text-sm text-theme-text-secondary">Deployment status is not reported.</p>}
+            {deployments.length > visibleEntries && <p className="text-xs text-theme-text-tertiary">Showing {visibleEntries} of {deployments.length} deployments, failures first. See YAML for the full list.</p>}
+          </div>
+        </div>
+      })}
+    {apps.length > visibleEntries && <p className="text-xs text-theme-text-tertiary">Showing {visibleEntries} of {apps.length} applications, failures first. See YAML for the full list.</p>}
+  </div>
+}
+
+export function RayServiceRenderer({ data, onNavigate, runtimeEvidence }: RayServiceRendererProps) {
+  const status = data.status ?? {}
+  const conditions = status.conditions ?? []
+  const generation = data.metadata?.generation
+  const suspended = data.spec?.suspend === true && conditions.some((condition: any) => condition.type === 'Suspended' && condition.status === 'True')
+  const behind = isRayObservationStale(generation, status.observedGeneration)
+  const ready = conditions.find((condition: any) => condition.type === 'Ready')
+  const readyStale = isRayServiceConditionStale(data, ready)
+  const readyLabel = ready?.status === 'True' ? 'Ready' : ready?.status === 'False' ? 'Not ready' : ready ? 'Unknown' : 'Not reported'
+  const slots = (['active', 'pending'] as const).filter(slot => status[`${slot}ServiceStatus`]?.rayClusterName)
+  return <>
+    {behind && !suspended && <AlertBanner variant="info" title="Observed generation differs" message={`Specification generation ${generation}; controller reports observed generation ${status.observedGeneration}. KubeRay can retain this value during suspension or terminal failure; conditions below preserve its reported state.`} />}
+    {behind && suspended && <p className="mb-3 text-sm text-theme-text-secondary">Reconciliation is paused while suspended; the controller may retain an earlier observed generation.</p>}
+    <Section title="Serving and Rollout" icon={Activity} defaultExpanded>
+      <PropertyList>
+        <Property label="Proxy Readiness" value={<Badge severity={readyStale ? 'neutral' : ready?.status === 'True' ? 'success' : ready?.status === 'False' ? 'warning' : 'neutral'}>{readyLabel}{readyStale ? ' (stale)' : ''}</Badge>} />
+        {ready?.reason && <Property label="Readiness Reason" value={ready.reason} />}
+        {status.numServeEndpoints != null && <Property label="Reported Serve Endpoints" value={status.numServeEndpoints} />}
+        <Property label="Suspension Requested" value={data.spec?.suspend === true ? 'Yes' : 'No'} />
+        <Property label="Declared Upgrade Strategy" value={data.spec?.upgradeStrategy?.type || 'Not specified'} />
+        {conditions.filter((condition: any) => ['UpgradeInProgress', 'RollbackInProgress', 'Suspending', 'Suspended'].includes(condition.type) && condition.status === 'True').map((condition: any) => <Property key={condition.type} label={condition.type} value={<Badge severity={isRayServiceConditionStale(data, condition) ? 'neutral' : condition.type === 'Suspended' ? 'info' : 'warning'}>{condition.reason || 'True'}{isRayServiceConditionStale(data, condition) ? ' (stale)' : ''}</Badge>} />)}
+      </PropertyList>
+      {ready?.message && <p className="mt-2 whitespace-pre-wrap break-words text-sm text-theme-text-secondary">{ready.message}</p>}
+      <p className="mt-2 text-xs text-theme-text-tertiary">Ready means Serve proxy endpoints are reported, not that every application or revision is healthy. Endpoint counts span revisions. Suspension is complete only when the controller reports Suspended.</p>
+      {status.observedGeneration == null && <p className="mt-2 text-xs text-theme-text-tertiary">The controller has not reported an observed generation.</p>}
+    </Section>
+    {slots.length === 0 && <Section title="Runtime Revisions" icon={GitBranch} defaultExpanded><p className="text-sm text-theme-text-secondary">No named runtime revision is reported.</p></Section>}
+    {slots.map(role => {
+      const slot = status[`${role}ServiceStatus`]
+      return <Section key={role} title={`${role === 'active' ? 'Active' : 'Pending'} Revision`} icon={GitBranch} defaultExpanded>
+        <div className="min-w-0 break-all [&_button]:text-left"><ResourceLink kind="rayclusters" group="ray.io" namespace={data.metadata?.namespace} name={slot.rayClusterName} onNavigate={onNavigate} /></div>
+        {runtimeEvidence?.[role] ?? <p className="mt-2 text-sm text-theme-text-secondary">Open the RayCluster for its directly observed runtime status.</p>}
+        {(slot.targetCapacity != null || slot.trafficRoutedPercent != null) && <div className="mt-3">
+          <PropertyList>
+            {slot.targetCapacity != null && <Property label="Serve Target Capacity" value={`${slot.targetCapacity}%`} />}
+            {slot.trafficRoutedPercent != null && <Property label="Configured Traffic Share" value={`${slot.trafficRoutedPercent}%`} />}
+          </PropertyList>
+          <p className="mt-1 text-xs text-theme-text-tertiary">Target capacity scales Serve replica targets. Traffic share is configured route weight, not measured requests.</p>
+        </div>}
+        <ServeApplications slot={slot} />
+      </Section>
+    })}
+    <ConditionsSection conditions={conditions} getConditionTone={condition => isRayServiceConditionStale(data, condition) ? 'unknown' : rayServiceConditionTone(condition)} defaultExpanded />
+  </>
+}

package/src/components/resources/renderers/index.ts

@@ -55,6 +55,7 @@ export * from './IstioPeerAuthenticationRenderer'
 export * from './IstioServiceEntryRenderer'
 export * from './IstioVirtualServiceRenderer'
 export * from './JobRenderer'
+export * from './JobSetRenderer'
 export * from './karpenter-cells'
 export * from './KarpenterEC2NodeClassRenderer'
 export * from './KarpenterNodeClaimRenderer'
@@ -179,3 +180,13 @@ export * from './KyvernoGlobalContextRenderer'
 export * from './KyvernoQueueRenderers'
 export * from './CNPGObjectStoreRenderer'
 export * from './CNPGDeclarativeRenderer'
+
+export { KueueWorkloadRenderer } from './KueueWorkloadRenderer'
+
+export { LocalQueueRenderer, ClusterQueueRenderer } from './KueueQueueRenderers'
+
+export { AdmissionCheckRenderer, ProvisioningRequestRenderer } from './KueueProvisioningRenderers'
+
+export { RayServiceRenderer } from './RayServiceRenderer'
+
+export { RayClusterRenderer } from './RayClusterRenderer'

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

@@ -74,13 +74,15 @@ describe('GPU ecosystem API contracts', () => {
     expect(getRayClusterStatus({
       status: {
         conditions: [{ type: 'HeadPodReady', status: 'True' }],
+        readyWorkerReplicas: 1,
         availableWorkerReplicas: 1,
         desiredWorkerReplicas: 2,
       },
-    }).text).toBe('Workers 1/2')
+    }).text).toBe('Workers 1/2 ready')
     expect(getRayClusterStatus({
       status: {
         conditions: [{ type: 'HeadPodReady', status: 'True' }],
+        readyWorkerReplicas: 2,
         availableWorkerReplicas: 2,
         desiredWorkerReplicas: 2,
       },
@@ -139,7 +141,87 @@ describe('GPU ecosystem API contracts', () => {
 
   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')
+    expect(getJobSetStatus({ status: { replicatedJobsStatus: [{ active: 1, ready: 0 }] } }).text).toBe('Active')
+    expect(getJobSetStatus({}).text).toBe('Unknown')
+  })
+
+  it('uses the same JobSet state precedence as execution context', () => {
+    const liveCounts = { replicatedJobsStatus: [{ active: 1, ready: 1 }] }
+
+    expect(getJobSetStatus({
+      spec: { suspend: true },
+      status: {
+        ...liveCounts,
+        terminalState: 'Failed',
+        conditions: [{ type: 'Completed', status: 'True' }],
+      },
+    }).text).toBe('Failed')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        terminalState: 'Completed',
+        conditions: [{ type: 'Failed', status: 'True', reason: 'ReachedMaxRestarts' }],
+      },
+    }).text).toBe('Completed')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        conditions: [
+          { type: 'Failed', status: 'True', reason: 'ReachedMaxRestarts' },
+          { type: 'Completed', status: 'True' },
+        ],
+      },
+    }).text).toBe('ReachedMaxRestarts')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        conditions: [
+          { type: 'Completed', status: 'True' },
+          { type: 'Suspended', status: 'True' },
+        ],
+      },
+    }).text).toBe('Completed')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        conditions: [
+          { type: 'Suspended', status: 'True' },
+          { type: 'RestartingJobSet', status: 'True' },
+        ],
+      },
+    }).text).toBe('Suspended')
+    expect(getJobSetStatus({
+      spec: { suspend: true },
+      status: {
+        ...liveCounts,
+        conditions: [{ type: 'RestartingJobSet', status: 'True' }],
+      },
+    }).text).toBe('Restarting')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        conditions: [
+          { type: 'RestartingJobSet', status: 'True' },
+          { type: 'StartupPolicyInProgress', status: 'True' },
+        ],
+      },
+    }).text).toBe('Starting')
+    expect(getJobSetStatus({
+      status: {
+        ...liveCounts,
+        conditions: [{ type: 'StartupPolicyInProgress', status: 'True' }],
+      },
+    }).text).toBe('Starting')
+  })
+
+  it('reports JobSet restart recovery and terminal-state fallbacks', () => {
+    expect(
+      getJobSetStatus({
+        status: { conditions: [{ type: 'RestartingJobSet', status: 'True' }], replicatedJobsStatus: [] },
+      }).text,
+    ).toBe('Restarting')
+    expect(getJobSetStatus({ status: { terminalState: 'Completed' } }).text).toBe('Completed')
+    expect(getJobSetStatus({ status: { terminalState: 'Failed' } }).text).toBe('Failed')
   })
 
   it('surfaces an unavailable LeaderWorkerSet before progress', () => {
@@ -234,3 +316,22 @@ describe('GPU ecosystem API contracts', () => {
     })).toBe('Worker 2/4 (2 failed)')
   })
 })
+
+describe('JobSet status evidence boundaries', () => {
+  it('does not turn pending Pods or child failures into root health or outcomes', () => {
+    for (const counts of [{ active: 1, ready: 0 }, { failed: 1 }, { succeeded: 1 }]) {
+      expect(getJobSetStatus({ status: { replicatedJobsStatus: [counts] } })).toMatchObject({ text: 'Active', level: 'neutral' })
+    }
+  })
+  it('requires observed counts for pending and preserves unknown native states', () => {
+    expect(getJobSetStatus({ status: {} }).text).toBe('Unknown')
+    expect(getJobSetStatus({ status: { replicatedJobsStatus: [{ active: 0 }] } }).text).toBe('Pending')
+    expect(getJobSetStatus({ status: { terminalState: 'Future', conditions: [{ type: 'Completed', status: 'True' }] } }).text).toBe('Unknown')
+  })
+  it('separates suspension intent and in-order resume evidence', () => {
+    expect(getJobSetStatus({ spec: { suspend: true }, status: { replicatedJobsStatus: [{ active: 1 }] } }).text).toBe('Active')
+    const conditions = [{ type: 'Suspended', status: 'True' }, { type: 'StartupPolicyInProgress', status: 'True' }]
+    expect(getJobSetStatus({ spec: { suspend: false }, status: { conditions } }).text).toBe('Starting')
+    expect(getJobSetStatus({ spec: { suspend: true }, status: { conditions } }).text).toBe('Suspended')
+  })
+})

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

@@ -3,6 +3,12 @@
 import type { StatusBadge } from './resource-utils'
 import { healthColors } from './resource-utils'
 
+export const JOBSET_API_VERSION = 'jobset.x-k8s.io/v1alpha2'
+
+export function isJobSetV1Alpha2(resource: any): boolean {
+  return resource?.kind === 'JobSet' && resource?.apiVersion === JOBSET_API_VERSION
+}
+
 // ============================================================================
 // LEADERWORKERSET UTILITIES
 // ============================================================================
@@ -61,28 +67,56 @@ export function getJobSetStatus(resource: any): StatusBadge {
   const conditions = resource.status?.conditions || []
 
   const failedCond = conditions.find((c: any) => c.type === 'Failed')
+  const completedCond = conditions.find((c: any) => c.type === 'Completed')
+
+  if (resource.status?.terminalState === 'Failed') {
+    return { text: failedCond?.status === 'True' ? failedCond.reason || 'Failed' : 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  if (resource.status?.terminalState === 'Completed') {
+    return { text: 'Completed', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  if (resource.status?.terminalState) {
+    return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+  }
+
   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 startupCond = conditions.find((c: any) => c.type === 'StartupPolicyInProgress')
+  // In-order resume retains Suspended until every role starts.
+  if (startupCond?.status === 'True' && resource.spec?.suspend !== true) {
+    return { text: 'Starting', color: healthColors.degraded, level: 'degraded' }
+  }
+
   const suspendedCond = conditions.find((c: any) => c.type === 'Suspended')
-  if (suspendedCond?.status === 'True' || resource.spec?.suspend === true) {
+  if (suspendedCond?.status === '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' }
+  const restartingCond = conditions.find((c: any) => c.type === 'RestartingJobSet')
+  if (restartingCond?.status === 'True') {
+    return { text: 'Restarting', color: healthColors.degraded, level: 'degraded' }
   }
-  if (resource.status) {
-    return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
+
+  if (startupCond?.status === 'True') {
+    return { text: 'Starting', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const statuses = resource.status?.replicatedJobsStatus
+  if (Array.isArray(statuses)) {
+    // Child activity includes Pending Pods and cleanup, not application health.
+    const activity = ['active', 'ready', 'succeeded', 'failed', 'suspended']
+      .some((field) => sumReplicatedJobsField(resource, field) > 0)
+    return activity
+      ? { text: 'Active', color: healthColors.neutral, level: 'neutral' }
+      : { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
   }
 
   return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }

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

@@ -5,6 +5,14 @@ import { healthColors } from './resource-utils'
 
 const failedFinishedReasons = new Set(['Failed', 'FailedToStart', 'OutOfSync', 'OwnerNotFound'])
 
+export function isKueueConditionStale(condition: { observedGeneration?: number } | undefined, generation?: number): boolean {
+  return !!condition?.observedGeneration && !!generation && condition.observedGeneration < generation
+}
+
+export function isKueueWorkloadFailureReason(reason: string): boolean {
+  return failedFinishedReasons.has(reason)
+}
+
 // ============================================================================
 // SHARED HELPERS
 // ============================================================================
@@ -24,6 +32,88 @@ function activeConditionStatus(resource: any): StatusBadge {
   return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
 }
 
+export function isKueueQueueResource(resource: any): boolean {
+  return resource?.apiVersion === 'kueue.x-k8s.io/v1beta1' || resource?.apiVersion === 'kueue.x-k8s.io/v1beta2'
+}
+
+export function getKueueQueueCondition(resource: any): any {
+  return findCondition(resource, 'Active')
+}
+
+function queueConditionStatus(resource: any): 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') {
+    return { text: 'Stopped', color: healthColors.neutral, level: 'neutral' }
+  }
+  return activeConditionStatus(resource)
+}
+
+type Quantity = string | number
+interface QueueResourceUsage {
+  name: string
+  total?: Quantity
+  borrowed?: Quantity
+}
+interface QueueFlavorUsage {
+  name: string
+  resources?: QueueResourceUsage[]
+}
+export interface KueueQuotaRow {
+  flavor: string
+  resource: string
+  configured: boolean
+  nominal?: Quantity
+  borrowingLimit?: Quantity
+  lendingLimit?: Quantity
+  reserved?: Quantity
+  used?: Quantity
+  borrowedReservation?: Quantity
+  borrowedUsage?: Quantity
+}
+
+export function getKueueQueueQuotaRows(resource: any, clusterQueue: boolean): KueueQuotaRow[] {
+  const rows = new Map<string, KueueQuotaRow>()
+  const rowFor = (flavor: string, name: string) => {
+    const key = JSON.stringify([flavor, name])
+    let row = rows.get(key)
+    if (!row) {
+      row = { flavor, resource: name, configured: false }
+      rows.set(key, row)
+    }
+    return row
+  }
+  if (clusterQueue) {
+    for (const group of resource?.spec?.resourceGroups ?? []) {
+      for (const flavor of group.flavors ?? []) {
+        for (const quota of flavor.resources ?? []) {
+          Object.assign(rowFor(flavor.name, quota.name), {
+            configured: true, nominal: quota.nominalQuota,
+            borrowingLimit: quota.borrowingLimit, lendingLimit: quota.lendingLimit,
+          })
+        }
+      }
+    }
+  }
+  const reservation: QueueFlavorUsage[] = resource?.status?.flavorsReservation ?? []
+  const usage: QueueFlavorUsage[] = !clusterQueue && resource?.apiVersion === 'kueue.x-k8s.io/v1beta1'
+    ? resource?.status?.flavorUsage ?? []
+    : resource?.status?.flavorsUsage ?? []
+  for (const flavor of reservation) {
+    for (const entry of flavor.resources ?? []) {
+      Object.assign(rowFor(flavor.name, entry.name), { reserved: entry.total, borrowedReservation: entry.borrowed })
+    }
+  }
+  for (const flavor of usage) {
+    for (const entry of flavor.resources ?? []) {
+      Object.assign(rowFor(flavor.name, entry.name), { used: entry.total, borrowedUsage: entry.borrowed })
+    }
+  }
+  return [...rows.values()]
+}
+
 function formatWorkloadCount(value: any): string {
   return typeof value === 'number' ? String(value) : '-'
 }
@@ -33,7 +123,7 @@ function formatWorkloadCount(value: any): string {
 // ============================================================================
 
 export function getClusterQueueStatus(resource: any): StatusBadge {
-  return activeConditionStatus(resource)
+  return queueConditionStatus(resource)
 }
 
 export function getClusterQueueCohort(resource: any): string {
@@ -64,7 +154,7 @@ export function getClusterQueueFlavors(resource: any): string {
 // ============================================================================
 
 export function getLocalQueueStatus(resource: any): StatusBadge {
-  return activeConditionStatus(resource)
+  return queueConditionStatus(resource)
 }
 
 export function getLocalQueueClusterQueue(resource: any): string {
@@ -83,36 +173,30 @@ export function getLocalQueueAdmittedWorkloads(resource: any): string {
 // KUEUE WORKLOAD UTILITIES
 // ============================================================================
 
-export function getKueueWorkloadStatus(resource: any): StatusBadge {
-  const finished = findCondition(resource, 'Finished')
-  if (finished?.status === 'True') {
-    if (failedFinishedReasons.has(finished.reason)) {
-      return { text: finished.reason, color: healthColors.unhealthy, level: 'unhealthy' }
-    }
-    return { text: 'Finished', color: healthColors.neutral, level: 'neutral' }
-  }
-
-  const evicted = findCondition(resource, 'Evicted')
-  if (evicted?.status === 'True') {
-    return { text: 'Evicted', color: healthColors.degraded, level: 'degraded' }
-  }
-
-  const preempted = findCondition(resource, 'Preempted')
-  if (preempted?.status === 'True') {
-    return { text: 'Preempted', color: healthColors.degraded, level: 'degraded' }
-  }
-
-  const admitted = findCondition(resource, 'Admitted')
-  if (admitted?.status === 'True') {
-    return { text: 'Admitted', color: healthColors.healthy, level: 'healthy' }
+export function getKueueWorkloadStatusCondition(resource: any): any {
+  for (const type of ['Finished', 'Evicted', 'Preempted', 'Admitted', 'QuotaReserved']) {
+    const condition = findCondition(resource, type)
+    if (condition?.status === 'True') return condition
   }
+}
 
-  const quotaReserved = findCondition(resource, 'QuotaReserved')
-  if (quotaReserved?.status === 'True') {
-    return { text: 'QuotaReserved', color: healthColors.neutral, level: 'neutral' }
+export function getKueueWorkloadStatus(resource: any): StatusBadge {
+  const condition = getKueueWorkloadStatusCondition(resource)
+  switch (condition?.type) {
+    case 'Finished':
+      return isKueueWorkloadFailureReason(condition.reason)
+        ? { text: condition.reason, color: healthColors.unhealthy, level: 'unhealthy' }
+        : { text: 'Finished', color: healthColors.neutral, level: 'neutral' }
+    case 'Evicted':
+    case 'Preempted':
+      return { text: condition.type, color: healthColors.degraded, level: 'degraded' }
+    case 'Admitted':
+      return { text: 'Admitted', color: healthColors.healthy, level: 'healthy' }
+    case 'QuotaReserved':
+      return { text: 'QuotaReserved', color: healthColors.neutral, level: 'neutral' }
+    default:
+      return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
   }
-
-  return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
 }
 
 export function getKueueWorkloadQueueName(resource: any): string {
@@ -151,6 +235,10 @@ export function getResourceFlavorTaintCount(resource: any): number {
 // ============================================================================
 
 export function getAdmissionCheckStatus(resource: any): StatusBadge {
+  const condition = findCondition(resource, 'Active')
+  if (isKueueConditionStale(condition, resource?.metadata?.generation)) {
+    return { text: 'Stale', color: healthColors.unknown, level: 'unknown' }
+  }
   return activeConditionStatus(resource)
 }
 
@@ -162,33 +250,40 @@ export function getAdmissionCheckControllerName(resource: any): string {
 // CLUSTER AUTOSCALER PROVISIONINGREQUEST UTILITIES
 // ============================================================================
 
-export function getProvisioningRequestStatus(resource: any): StatusBadge {
-  const failed = findCondition(resource, 'Failed')
-  if (failed?.status === 'True') {
-    return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
-  }
-
-  const capacityRevoked = findCondition(resource, 'CapacityRevoked')
-  if (capacityRevoked?.status === 'True') {
-    return { text: 'CapacityRevoked', color: healthColors.degraded, level: 'degraded' }
+export function getProvisioningRequestStatusCondition(resource: any): any {
+  for (const type of ['Failed', 'CapacityRevoked', 'BookingExpired', 'Provisioned', 'Accepted']) {
+    const condition = findCondition(resource, type)
+    if (condition?.status === 'True') return condition
   }
+}
 
-  const bookingExpired = findCondition(resource, 'BookingExpired')
-  if (bookingExpired?.status === 'True') {
-    return { text: 'BookingExpired', color: healthColors.degraded, level: 'degraded' }
+export function getProvisioningRequestMessage(resource: any): string | undefined {
+  const condition = getProvisioningRequestStatusCondition(resource)
+  if (condition?.type === 'Accepted') {
+    const progress = findCondition(resource, 'Provisioned')
+    if (progress?.status === 'False' && !isKueueConditionStale(progress, resource?.metadata?.generation) && progress.message) return progress.message
   }
+  return condition?.message
+}
 
-  const provisioned = findCondition(resource, 'Provisioned')
-  if (provisioned?.status === 'True') {
-    return { text: 'Provisioned', color: healthColors.healthy, level: 'healthy' }
+export function getProvisioningRequestStatus(resource: any): StatusBadge {
+  const condition = getProvisioningRequestStatusCondition(resource)
+  if (isKueueConditionStale(condition, resource?.metadata?.generation)) {
+    return { text: `${condition.type} (stale)`, color: healthColors.unknown, level: 'unknown' }
   }
-
-  const accepted = findCondition(resource, 'Accepted')
-  if (accepted?.status === 'True') {
-    return { text: 'Accepted', color: healthColors.neutral, level: 'neutral' }
+  switch (condition?.type) {
+    case 'Failed':
+    case 'CapacityRevoked':
+      return { text: condition.type, color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'BookingExpired':
+      return { text: 'BookingExpired', color: healthColors.neutral, level: 'neutral' }
+    case 'Provisioned':
+      return { text: 'Provisioned', color: healthColors.healthy, level: 'healthy' }
+    case 'Accepted':
+      return { text: 'Accepted', color: healthColors.neutral, level: 'neutral' }
+    default:
+      return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
   }
-
-  return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
 }
 
 export function getProvisioningRequestClassName(resource: any): string {