@skyhook-io/k8s-ui 1.13.3 → 1.14.0

package/src/components/shared/ResourceActionsBar.tsx

@@ -22,10 +22,15 @@ import { classifyDiffLine } from './UnifiedDiff'
 import { Tooltip } from '../ui/Tooltip'
 import { ForceDeleteConfirmDialog, type CascadeDependent } from '../ui/ForceDeleteConfirmDialog'
 import { ConfirmDialog } from '../ui/ConfirmDialog'
+import { AlertBanner } from '../ui/drawer-components'
 import { DialogPortal } from '../ui/DialogPortal'
 import type { SelectedResource, WorkloadRevision } from '../../types'
 import { displayKindName } from '../ui/drawer-components'
 import { getDefaultContainerName } from '../resources/resource-utils'
+import { SetImageDialog, type ManagedImageSource } from './SetImageDialog'
+import type { WorkloadImageInventory, WorkloadImageUpdate } from '../../types/core'
+import { isArgoRolloutResource } from '../../utils/workload-rollout'
+import { isCoreBatchJob } from '../../utils/api-resources'
 
 // ============================================================================
 // ACTIONS BAR - Interactive buttons that change based on resource kind
@@ -76,6 +81,11 @@ interface ResourceActionsBarProps {
   onRestart?: (params: { kind: string; namespace: string; name: string }, callbacks?: { onSuccess?: () => void; onError?: (err: unknown) => void }) => void
   isRestarting?: boolean
 
+  onLoadImages?: (params: { kind: string; namespace: string; name: string }) => Promise<WorkloadImageInventory>
+  onSetImages?: (params: { kind: string; namespace: string; name: string; updates: WorkloadImageUpdate[] }) => Promise<unknown>
+  isSettingImages?: boolean
+  managedImageSources?: ManagedImageSource[]
+
   // Rollback
   revisions?: WorkloadRevision[]
   revisionsLoading?: boolean
@@ -136,6 +146,7 @@ export function ResourceActionsBar({
   renderPortForward,
   onDelete, isDeleting, cascadeDependents, cascadeLoading, cascadeRootResolved,
   onRestart, isRestarting,
+  onLoadImages, onSetImages, isSettingImages, managedImageSources,
   revisions: revisionsList, revisionsLoading, revisionsError, onRollback, isRollingBack,
   onRolloutPromoteFull,
   onTriggerCronJob, isTriggeringCronJob,
@@ -156,11 +167,14 @@ export function ResourceActionsBar({
   onDrainNode, isDrainingNode,
 }: ResourceActionsBarProps) {
   const kind = resource.kind.toLowerCase()
+  const coreBatchJob = isCoreBatchJob(kind, resource.group)
+  const supportsWorkloadActions = ['deployments', 'statefulsets', 'daemonsets'].includes(kind) ||
+    (kind === 'rollouts' && isArgoRolloutResource(data))
   const canOpenWorkloadLogs = Boolean(
     canViewLogs &&
     !hideLogs &&
     openWorkloadLogs &&
-    ['deployments', 'statefulsets', 'daemonsets', 'jobs', 'workflows', 'cronjobs', 'cronworkflows', 'workflowtemplates', 'clusterworkflowtemplates', 'scaledjobs'].includes(kind)
+    (['deployments', 'statefulsets', 'daemonsets', 'workflows', 'cronjobs', 'cronworkflows', 'workflowtemplates', 'clusterworkflowtemplates', 'scaledjobs'].includes(kind) || coreBatchJob)
   )
 
   // Delete confirmation state
@@ -173,6 +187,7 @@ export function ResourceActionsBar({
 
   // Rollback dialog state
   const [showRevisions, setShowRevisions] = useState(false)
+  const [showSetImage, setShowSetImage] = useState(false)
   const isRollbackKind = ['deployments', 'statefulsets', 'daemonsets', 'rollouts'].includes(kind)
   const hasMultipleRevisions = (revisionsList?.length ?? 0) > 1
 
@@ -235,7 +250,7 @@ export function ResourceActionsBar({
   }
 
   return (
-    <div className="flex items-center gap-2 px-4 py-2 flex-wrap">
+    <div className="flex items-center gap-1.5 px-4 py-2 flex-wrap">
       {/* Kind-specific actions (left) */}
       {kind === 'pods' && (
         <>
@@ -298,7 +313,7 @@ export function ResourceActionsBar({
           {canExec && onOpenNodeTerminal && (
             <button
               onClick={() => onOpenNodeTerminal({ nodeName: resource.name })}
-              className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium btn-brand rounded-lg"
+              className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
             >
               <Terminal className="w-3.5 h-3.5" />
               Debug Shell
@@ -357,29 +372,44 @@ export function ResourceActionsBar({
       )}
 
       {/* Workload actions - restart, rollback, and logs */}
-      {['deployments', 'statefulsets', 'daemonsets', 'rollouts'].includes(kind) && (
+      {supportsWorkloadActions && (
         <>
-          {onRestart && (
+          {onLoadImages && onSetImages && !data?.metadata?.deletionTimestamp && (
             <button
-              onClick={() => onRestart({
-                kind: resource.kind,
-                namespace: resource.namespace,
-                name: resource.name,
-              })}
-              disabled={isRestarting}
-              className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
+              onClick={() => setShowSetImage(true)}
+              className="flex items-center gap-1.5 px-2 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
             >
-              <RefreshCw className={`w-3.5 h-3.5 ${isRestarting ? 'animate-spin' : ''}`} />
-              {isRestarting ? 'Restarting...' : 'Restart'}
+              <Box className="w-3.5 h-3.5" />
+              Set image
             </button>
           )}
+          {onRestart && (
+            <>
+              <button
+                onClick={() => onRestart({
+                  kind: resource.kind,
+                  namespace: resource.namespace,
+                  name: resource.name,
+                })}
+                disabled={isRestarting}
+                aria-busy={isRestarting}
+                className="flex items-center gap-1.5 px-2 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
+              >
+                <RefreshCw className={`w-3.5 h-3.5 ${isRestarting ? 'animate-spin' : ''}`} />
+                Restart
+              </button>
+              <span className="sr-only" aria-live="polite">
+                {isRestarting ? 'Restarting workload' : ''}
+              </span>
+            </>
+          )}
           {isRollbackKind && onRollback && (
             <Tooltip content={hasMultipleRevisions ? 'View revision history and rollback' : 'Only one revision exists'} delay={150}>
               <button
                 onClick={() => setShowRevisions(true)}
                 disabled={!hasMultipleRevisions}
                 className={clsx(
-                  "flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg transition-colors",
+                  "flex items-center gap-1.5 px-2 py-1.5 text-xs font-medium rounded-lg transition-colors",
                   hasMultipleRevisions
                     ? "text-white bg-amber-600 hover:bg-amber-700"
                     : "text-theme-text-disabled bg-theme-elevated"
@@ -480,7 +510,7 @@ export function ResourceActionsBar({
             workloadKind: kind,
             workloadName: resource.name,
           })}
-          className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
+          className="flex items-center gap-1.5 px-2 py-1.5 text-xs font-medium btn-brand-muted rounded-lg"
         >
           <FileText className="w-3.5 h-3.5" />
           Logs
@@ -488,7 +518,7 @@ export function ResourceActionsBar({
       )}
 
       {/* Job logs */}
-      {kind === 'jobs' && onCopyCommand && (!canViewLogs || !openWorkloadLogs) && (
+      {coreBatchJob && onCopyCommand && (!canViewLogs || !openWorkloadLogs) && (
         <button
           onClick={(e) => onCopyCommand(
             `kubectl logs job/${resource.name} -n ${resource.namespace} -f`,
@@ -527,7 +557,7 @@ export function ResourceActionsBar({
           <button
             onClick={onToggleYaml}
             className={clsx(
-              'flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg transition-colors',
+              'flex items-center gap-1.5 px-2 py-1.5 text-xs font-medium rounded-lg transition-colors',
               showYaml
                 ? 'btn-brand'
                 : 'text-theme-text-secondary hover:text-theme-text-primary border border-theme-border-light hover:bg-theme-elevated'
@@ -616,6 +646,20 @@ export function ResourceActionsBar({
         cascadeRootResolved={cascadeRootResolved}
       />
 
+      {onLoadImages && onSetImages && (
+        <SetImageDialog
+          open={showSetImage}
+          workloadLabel={`${displayKindName(resource.kind, data?.kind)} ${resource.namespace}/${resource.name}`}
+          workloadName={resource.name}
+          workloadResource={resource.kind}
+          managedSources={managedImageSources}
+          pending={isSettingImages}
+          onClose={() => setShowSetImage(false)}
+          onLoad={() => onLoadImages({ kind: resource.kind, namespace: resource.namespace, name: resource.name })}
+          onConfirm={(updates) => onSetImages({ kind: resource.kind, namespace: resource.namespace, name: resource.name, updates })}
+        />
+      )}
+
       {/* Node cordon confirmation */}
       <ConfirmDialog
         open={showCordonConfirm}
@@ -915,17 +959,55 @@ export function revisionRoleBadges(rev: WorkloadRevision, isRollout: boolean): R
   return badges
 }
 
-// Awaits promote-full so the dialog cannot close on a half-landed rollback. A
-// failure is reported by the mutation's error toast, so it must not block the close.
+// Awaits promote-full so the dialog cannot close on a half-landed rollback, and reports
+// whether it landed: the rollback has already succeeded by this point, so a failure here
+// leaves the Rollout replaying its canary steps and the operator has to be told which
+// half of the pair still needs them.
+export interface PromoteFailure {
+  message: string
+  // Only a lagging controller clears on its own. The status cannot say that — a lost
+  // cluster connection also answers 503 — so this reads the error code the server sends.
+  controllerLagging: boolean
+}
+
+// What the operator is told when the rollback landed and the promotion did not. Kept
+// apart from the markup so the wording and the retry decision can be tested.
+export function promoteFailureGuidance(failure: PromoteFailure): {
+  body: string
+  canRetry: boolean
+} {
+  const shared =
+    'The rollback is live and is re-running the canary steps you asked to skip. ' +
+    'If any of them is a manual pause it will stop there until someone promotes it.'
+  if (failure.controllerLagging) {
+    return {
+      body: `${shared} The Argo Rollouts controller had not caught up yet, which usually clears within a few seconds.`,
+      canRetry: true,
+    }
+  }
+  return {
+    body: `${shared} Promote full is also available from the rollout page once this is resolved.`,
+    canRetry: false,
+  }
+}
+
 export async function completePromoteAfterRollback(
   promote: () => void | Promise<unknown>,
   setPending: (pending: boolean) => void,
-): Promise<void> {
+): Promise<{ promoted: boolean; error?: PromoteFailure }> {
   setPending(true)
   try {
     await promote()
-  } catch {
-    // already surfaced to the user
+    return { promoted: true }
+  } catch (err) {
+    const code = (err as { data?: { error_code?: string } })?.data?.error_code
+    return {
+      promoted: false,
+      error: {
+        message: err instanceof Error ? err.message : String(err),
+        controllerLagging: code === 'controller_not_caught_up',
+      },
+    }
   } finally {
     setPending(false)
   }
@@ -948,6 +1030,8 @@ export function RevisionHistoryDialog({ kind, namespace, name, open, onClose, re
   const [diffRevision, setDiffRevision] = useState<number | null>(null)
   const [promoteAfterRollback, setPromoteAfterRollback] = useState(false)
   const [promotingFull, setPromotingFull] = useState(false)
+  const [promoteError, setPromoteError] = useState<PromoteFailure | null>(null)
+  const retryButtonRef = useRef<HTMLButtonElement>(null)
 
   const handleClose = () => { setDiffRevision(null); onClose() }
 
@@ -958,20 +1042,34 @@ export function RevisionHistoryDialog({ kind, namespace, name, open, onClose, re
   const isRollout = isRolloutKind(kind)
   const canPromoteAfterRollback = offersPromoteAfterRollback(kind, Boolean(onRolloutPromoteFull))
 
+  // The Confirm button unmounts when the panel appears, so focus would land on <body>
+  // and a keyboard user would have to tab the whole dialog to reach the retry.
+  useEffect(() => {
+    if (promoteError) retryButtonRef.current?.focus()
+  }, [promoteError])
+
   const currentRevision = revisions?.find(r => r.isCurrent)
   const selectedRevision = revisions?.find(r => r.number === diffRevision)
   const hasDiffData = currentRevision?.template && selectedRevision?.template
 
   function handleRollback(revision: number) {
+    setPromoteError(null)
     onRollback?.(
       { kind, namespace, name, revision },
       {
         onSuccess: async () => {
           if (canPromoteAfterRollback && promoteAfterRollback && onRolloutPromoteFull) {
-            await completePromoteAfterRollback(
+            const outcome = await completePromoteAfterRollback(
               () => onRolloutPromoteFull({ namespace, name }),
               setPromotingFull,
             )
+            if (!outcome.promoted) {
+              // Closing here would leave the operator with a green "rollback initiated"
+              // toast and a canary still running every step they asked to skip.
+              setPromoteError(outcome.error ?? { message: 'The promotion did not go through.', controllerLagging: false })
+              setConfirmRevision(null)
+              return
+            }
           }
           setConfirmRevision(null)
           setDiffRevision(null)
@@ -981,6 +1079,21 @@ export function RevisionHistoryDialog({ kind, namespace, name, open, onClose, re
     )
   }
 
+  async function retryPromoteFull() {
+    if (!onRolloutPromoteFull) return
+    const outcome = await completePromoteAfterRollback(
+      () => onRolloutPromoteFull({ namespace, name }),
+      setPromotingFull,
+    )
+    if (outcome.promoted) {
+      setPromoteError(null)
+      setDiffRevision(null)
+      onClose()
+      return
+    }
+    setPromoteError(outcome.error ?? { message: 'The promotion did not go through.', controllerLagging: false })
+  }
+
   function formatTimeAgo(dateStr: string): string {
     const date = new Date(dateStr)
     const now = new Date()
@@ -1120,7 +1233,11 @@ export function RevisionHistoryDialog({ kind, namespace, name, open, onClose, re
                               disabled={busy}
                               className="px-2 py-0.5 text-xs font-medium text-white bg-amber-600 hover:bg-amber-700 rounded transition-colors disabled:opacity-50"
                             >
-                              {promotingFull ? 'Promoting...' : isRollingBack ? 'Rolling back...' : 'Confirm'}
+                              {promotingFull
+                                ? 'Waiting for the controller…'
+                                : isRollingBack
+                                  ? 'Rolling back...'
+                                  : 'Confirm'}
                             </button>
                             <button
                               onClick={() => setConfirmRevision(null)}
@@ -1157,6 +1274,34 @@ export function RevisionHistoryDialog({ kind, namespace, name, open, onClose, re
         )}
       </div>
 
+      {promoteError && (
+        <div className="mx-4 shrink-0" role="alert">
+          <AlertBanner
+            variant="warning"
+            title="Rolled back, but not promoted"
+            message={
+              <>
+                {promoteFailureGuidance(promoteError).body}
+                <span className="block mt-1 text-theme-text-tertiary break-words">
+                  {promoteError.message}
+                </span>
+              </>
+            }
+          >
+            {promoteFailureGuidance(promoteError).canRetry && (
+              <button
+                ref={retryButtonRef}
+                onClick={retryPromoteFull}
+                disabled={busy}
+                className="mt-2 px-2 py-0.5 text-xs font-medium text-white bg-amber-600 hover:bg-amber-700 rounded transition-colors disabled:opacity-50"
+              >
+                {promotingFull ? 'Waiting for the controller…' : 'Promote fully'}
+              </button>
+            )}
+          </AlertBanner>
+        </div>
+      )}
+
       <div className="flex items-center justify-between gap-4 p-4 border-t border-theme-border shrink-0">
         {canPromoteAfterRollback ? (
           <label className="flex items-center gap-2 text-sm text-theme-text-secondary">

package/src/components/shared/ResourceRendererDispatch.test.tsx

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { renderToString } from 'react-dom/server'
 import { ResourceRendererDispatch, getResourceStatus, type RendererOverrides } from './ResourceRendererDispatch'
+import { getCellFilterValue } from '../resources/resource-utils'
 import type { ResourceRef } from '../../types'
 
 function renderWithScalers(scalers: ResourceRef[]): string {
@@ -179,6 +180,78 @@ function renderCollidingKind(kind: string, apiVersion: string): string {
   )
 }
 
+describe('getResourceStatus — workload rollout activity', () => {
+  const steadyDegraded = {
+    metadata: { generation: 4 },
+    spec: { replicas: 3 },
+    status: { observedGeneration: 4, replicas: 3, updatedReplicas: 3, readyReplicas: 2, availableReplicas: 2 },
+  }
+
+  it('keeps steady-state availability as health instead of rollout activity', () => {
+    expect(getResourceStatus('deployments', steadyDegraded)).toMatchObject({ text: '2/3', level: 'degraded' })
+    expect(getCellFilterValue(steadyDegraded, 'status', 'deployments')).toBe('Degraded')
+  })
+
+  it('uses the rollout label consistently while a revision is moving', () => {
+    const rolling = {
+      metadata: { generation: 4 },
+      spec: { replicas: 3 },
+      status: { observedGeneration: 4, replicas: 4, updatedReplicas: 2, readyReplicas: 3, availableReplicas: 3 },
+    }
+    expect(getResourceStatus('deployments', rolling)?.text).toBe('Rolling out')
+    expect(getCellFilterValue(rolling, 'status', 'deployments')).toBe('Rolling out')
+  })
+
+  it('keeps scaled-to-zero workloads neutral', () => {
+    const scaled = { metadata: { generation: 2 }, spec: { replicas: 0 }, status: { observedGeneration: 2 } }
+    expect(getResourceStatus('deployments', scaled)).toMatchObject({ text: 'Scaled to 0', level: 'neutral' })
+    expect(getCellFilterValue(scaled, 'status', 'deployments')).toBe('Scaled to 0')
+  })
+
+  it('treats a foreign Rollout CRD as unknown', () => {
+    const rollout = {
+      apiVersion: 'rollouts.kruise.io/v1alpha1',
+      kind: 'Rollout',
+      metadata: { name: 'foreign' },
+      spec: { replicas: 3 },
+      status: { readyReplicas: 3, availableReplicas: 3, updatedReplicas: 3 },
+    }
+    expect(getResourceStatus('rollouts', rollout)).toMatchObject({ text: 'Unknown', level: 'unknown' })
+  })
+
+  it('uses merged rollout and serving health for Argo Rollouts', () => {
+    const rollout = {
+      apiVersion: 'argoproj.io/v1alpha1',
+      metadata: { generation: 2 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: '2',
+        phase: 'Progressing',
+        updatedReplicas: 1,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }
+
+    expect(getResourceStatus('rollouts', rollout)).toMatchObject({ text: 'Degraded · Rolling out', level: 'degraded' })
+  })
+})
+
+describe('Rollout kind collision', () => {
+  it('routes foreign Rollouts to the generic renderer', () => {
+    const html = renderKind('rollouts', {
+      apiVersion: 'rollouts.kruise.io/v1alpha1',
+      kind: 'Rollout',
+      metadata: { name: 'foreign', namespace: 'default' },
+      spec: { collisionProbe: COLLISION_PROBE },
+      status: {},
+    }, 'default')
+
+    expect(html).toContain(COLLISION_PROBE)
+    expect(html).not.toContain('Rollout Strategy')
+  })
+})
+
 describe('getResourceStatus — colliding plurals', () => {
   it('fabricates no PostgreSQL status for a third-party clusters CRD', () => {
     // KubeBlocks, Redis/Valkey operators and friends all ship `clusters`. With
@@ -582,14 +655,27 @@ describe('shared plurals — the status path collides too', () => {
   // The renderer and the status badge are two separate switches over the same
   // plural, and fixing one leaves the other reading a foreign CRD's conditions
   // as if they were Knative's.
+  // Phase-only on purpose. Knative reports a bare "Unknown" for a resource with
+  // no conditions, while the generic path reports the phase — so this fixture
+  // tells the two apart. A Ready=False condition would not: both paths surface
+  // the same text for it, and pinning which of phase/conditions wins is a
+  // separate concern that generic-status.test.ts owns.
   it('does not give a foreign subscriptions CRD a Knative status', () => {
     const s = getResourceStatus('subscriptions', {
       apiVersion: 'operators.coreos.com/v1alpha1',
-      status: { conditions: [{ type: 'Ready', status: 'False' }], phase: 'AtLatestKnown' },
+      status: { phase: 'AtLatestKnown' },
     })
     expect(s?.text).toBe('AtLatestKnown')
   })
 
+  it('still routes a Knative subscription to the Knative status', () => {
+    const s = getResourceStatus('subscriptions', {
+      apiVersion: 'messaging.knative.dev/v1',
+      status: { phase: 'AtLatestKnown' },
+    })
+    expect(s?.text).toBe('Unknown')
+  })
+
   it('still gives Knative its own status', () => {
     const s = getResourceStatus('subscriptions', {
       apiVersion: 'messaging.knative.dev/v1',
@@ -640,3 +726,122 @@ describe('Velero BackupRepository status', () => {
     expect(getResourceStatus('backuprepositories', foreign)?.text).not.toBe('Not ready')
   })
 })
+
+describe('GPU ecosystem kind collisions', () => {
+  it('routes Volcano Jobs away from the core JobRenderer to GenericRenderer', () => {
+    const html = renderKind('jobs', {
+      apiVersion: 'batch.volcano.sh/v1alpha1',
+      kind: 'Job',
+      metadata: { name: 'train', namespace: 'ml' },
+      spec: { queue: 'gpu-queue', minAvailable: 4 },
+      status: { state: { phase: 'Running' } },
+    }, 'ml')
+    expect(html).toContain('Min Available')
+    expect(html).toContain('gpu-queue')
+    expect(html).not.toContain('Completions')
+  })
+
+  it('routes status for queues by group (Volcano vs KAI)', () => {
+    const volcano = getResourceStatus('queues', {
+      apiVersion: 'scheduling.volcano.sh/v1beta1',
+      status: { state: 'Open' },
+    })
+    const kai = getResourceStatus('queues', {
+      apiVersion: 'scheduling.run.ai/v2',
+      spec: { priority: 100 },
+    })
+    expect(volcano?.text).toBe('Open')
+    expect(kai?.text).not.toBe('Open')
+  })
+
+  it('routes status for podgroups by group (Volcano vs KAI)', () => {
+    const volcano = getResourceStatus('podgroups', {
+      apiVersion: 'scheduling.volcano.sh/v1beta1',
+      status: { phase: 'Running' },
+    })
+    expect(volcano?.text).toBe('Running')
+  })
+
+  it('routes Kueue Workload status only for the kueue group', () => {
+    const admitted = getResourceStatus('workloads', {
+      apiVersion: 'kueue.x-k8s.io/v1beta2',
+      status: { conditions: [{ type: 'Admitted', status: 'True' }] },
+    })
+    expect(admitted?.text).toBe('Admitted')
+    const foreign = getResourceStatus('workloads', {
+      apiVersion: 'scheduling.k8s.io/v1alpha2',
+      status: { conditions: [{ type: 'Admitted', status: 'True' }] },
+    })
+    expect(foreign?.text).toBe('Admitted')
+    expect(foreign?.color).not.toBe(admitted?.color)
+  })
+
+  it('does not assign Volcano or core Job semantics to foreign collisions', () => {
+    const foreign = {
+      apiVersion: 'example.io/v1',
+      kind: 'Job',
+      metadata: { name: 'foreign', namespace: 'default' },
+      spec: { collisionProbe: COLLISION_PROBE },
+      status: { state: { phase: 'Running' } },
+    }
+    expect(getResourceStatus('jobs', foreign)).toBeNull()
+    const html = renderKind('jobs', foreign, 'default')
+    expect(html).toContain(COLLISION_PROBE)
+    expect(html).not.toContain('Completions')
+  })
+
+  it('keeps typed core Jobs on the core path when TypeMeta is absent', () => {
+    const core = {
+      kind: 'Job',
+      metadata: { name: 'core', namespace: 'default' },
+      spec: { completions: 1, parallelism: 1 },
+      status: { succeeded: 1, conditions: [{ type: 'Complete', status: 'True' }] },
+    }
+    expect(getResourceStatus('jobs', core)?.text).toBe('Complete')
+    const html = renderKind('jobs', core, 'default')
+    expect(html).toContain('Completions')
+  })
+
+  it('leaves foreign Queues and PodGroups on generic status handling', () => {
+    expect(getResourceStatus('queues', { apiVersion: 'example.io/v1', status: {} })).toBeNull()
+    expect(getResourceStatus('podgroups', { apiVersion: 'example.io/v1', status: {} })).toBeNull()
+  })
+
+  it('accepts the current llm-d InferenceObjective group', () => {
+    expect(getResourceStatus('inferenceobjectives', {
+      apiVersion: 'llm-d.ai/v1alpha2',
+      status: { conditions: [{ type: 'Ready', status: 'True' }] },
+    })?.text).toBe('Accepted')
+  })
+
+  it('routes KAITO Workspace status only for the kaito group', () => {
+    const ws = getResourceStatus('workspaces', {
+      apiVersion: 'kaito.sh/v1beta1',
+      status: { conditions: [{ type: 'ResourceReady', status: 'False' }] },
+    })
+    expect(ws).not.toBeNull()
+  })
+})
+
+describe('GPU ecosystem status edge cases', () => {
+  it('JobSet with minimal status is Pending, not Running', () => {
+    const fresh = getResourceStatus('jobsets', {
+      apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      status: { replicatedJobsStatus: [{ name: 'w', active: 0, ready: 0 }] },
+    })
+    const live = getResourceStatus('jobsets', {
+      apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      status: { replicatedJobsStatus: [{ name: 'w', active: 1, ready: 1 }] },
+    })
+    expect(fresh?.text).toBe('Pending')
+    expect(live?.text).toBe('Running')
+  })
+
+  it('InferencePool with only an empty-parentRef default entry reads Not referenced', () => {
+    const pool = getResourceStatus('inferencepools', {
+      apiVersion: 'inference.networking.x-k8s.io/v1alpha2',
+      status: { parent: [{ parentRef: {}, conditions: [{ type: 'Accepted', status: 'Unknown' }] }] },
+    })
+    expect(pool?.text).toBe('Not referenced')
+  })
+})