@skyhook-io/k8s-ui 1.4.0 → 1.4.2

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

@@ -1,4 +1,4 @@
-import { Play, Clock, CheckCircle, XCircle, Loader2 } from 'lucide-react'
+import { Play, Clock, CheckCircle, XCircle, Loader2, SkipForward, PauseCircle } from 'lucide-react'
 import { clsx } from 'clsx'
 import { Section, PropertyList, Property, ConditionsSection, AlertBanner } from '../../ui/drawer-components'
 import { formatAge, formatDuration } from '../resource-utils'
@@ -13,6 +13,8 @@ interface WorkflowStep {
   phase: string
   startedAt: string | null
   finishedAt: string | null
+  message: string | null
+  nodeType: string
 }
 
 function getStepDuration(step: WorkflowStep): string | null {
@@ -22,7 +24,13 @@ function getStepDuration(step: WorkflowStep): string | null {
   return formatDuration(end.getTime() - start.getTime(), true)
 }
 
-function StepStatusIcon({ phase }: { phase: string }) {
+function StepStatusIcon({ phase, nodeType }: { phase: string; nodeType?: string }) {
+  if (nodeType === 'Skipped' || phase === 'Skipped') {
+    return <SkipForward className="w-4 h-4 text-theme-text-tertiary shrink-0" />
+  }
+  if (nodeType === 'Suspend' && phase !== 'Succeeded') {
+    return <PauseCircle className="w-4 h-4 text-yellow-400 shrink-0" />
+  }
   switch (phase) {
     case 'Succeeded':
       return <CheckCircle className="w-4 h-4 text-green-400 shrink-0" />
@@ -46,6 +54,9 @@ function getPhaseBadgeClass(phase: string): string {
       return 'status-unhealthy'
     case 'Pending':
       return 'status-degraded'
+    case 'Skipped':
+    case 'Omitted':
+      return 'status-unknown'
     default:
       return 'status-unknown'
   }
@@ -74,29 +85,39 @@ function getWorkflowProblems(data: any): string[] {
     problems.push(status.message || 'Workflow error')
   }
 
-  // Check for failed nodes
+  // Check for failed nodes — include error messages when available
   const nodes = status.nodes || {}
-  const failedSteps = Object.values(nodes)
-    .filter((node: any) => node.type === 'Pod' && node.phase === 'Failed')
-    .map((node: any) => node.displayName)
+  const failedNodes = Object.values(nodes)
+    .filter((node: any) => (node.type === 'Pod' || node.type === 'Suspend' || node.type === 'Skipped') && (node.phase === 'Failed' || node.phase === 'Error'))
 
-  if (failedSteps.length > 0) {
-    problems.push(`Failed steps: ${failedSteps.join(', ')}`)
+  if (failedNodes.length > 0) {
+    const withMessages = failedNodes.filter((node: any) => node.message)
+    if (withMessages.length > 0) {
+      for (const n of withMessages as any[]) {
+        problems.push(`${n.displayName}: ${n.message}`)
+      }
+    } else {
+      problems.push(`Failed steps: ${failedNodes.map((n: any) => n.displayName).join(', ')}`)
+    }
   }
 
   return problems
 }
 
+const VISIBLE_NODE_TYPES = new Set(['Pod', 'Skipped', 'Suspend'])
+
 function extractSteps(data: any): WorkflowStep[] {
   const nodes = data.status?.nodes || {}
   const steps: WorkflowStep[] = Object.entries(nodes)
-    .filter(([, node]: [string, any]) => node.type === 'Pod')
+    .filter(([, node]: [string, any]) => VISIBLE_NODE_TYPES.has(node.type))
     .map(([id, node]: [string, any]) => ({
       id,
       displayName: node.displayName || id,
-      phase: node.phase || 'Pending',
+      phase: node.phase || (node.type === 'Skipped' ? 'Skipped' : 'Pending'),
       startedAt: node.startedAt || null,
       finishedAt: node.finishedAt || null,
+      message: node.message || null,
+      nodeType: node.type,
     }))
 
   steps.sort((a, b) => {
@@ -163,9 +184,22 @@ export function WorkflowRenderer({ data }: WorkflowRendererProps) {
           {status.startedAt && <Property label="Started" value={formatAge(status.startedAt)} />}
           <Property label="Finished" value={status.finishedAt ? formatAge(status.finishedAt) : 'Running...'} />
           {templateName && <Property label="Template" value={templateName} />}
+          {status.progress && (
+            <Property label="Progress" value={status.progress} />
+          )}
           {estimatedDuration != null && (
             <Property label="Estimated Duration" value={formatEstimatedDuration(estimatedDuration)} />
           )}
+          {status.resourcesDuration && (
+            <Property
+              label="Resource Usage"
+              value={
+                Object.entries(status.resourcesDuration as Record<string, number>)
+                  .map(([resource, seconds]) => `${resource}: ${seconds}s`)
+                  .join(', ')
+              }
+            />
+          )}
         </PropertyList>
       </Section>
 
@@ -173,13 +207,33 @@ export function WorkflowRenderer({ data }: WorkflowRendererProps) {
       {steps.length > 0 && (
         <Section title={`Steps (${steps.length})`} defaultExpanded>
           <div className="space-y-1.5">
-            {steps.map(step => (
-              <div key={step.id} className="flex items-center gap-2 text-sm card-inner px-3 py-2">
-                <StepStatusIcon phase={step.phase} />
-                <span className="flex-1 text-theme-text-primary">{step.displayName}</span>
-                <span className="text-xs text-theme-text-secondary">{getStepDuration(step) || '-'}</span>
-              </div>
-            ))}
+            {steps.map(step => {
+              const isFailed = step.phase === 'Failed' || step.phase === 'Error'
+              const isSkipped = step.nodeType === 'Skipped' || step.phase === 'Skipped'
+              const isSuspend = step.nodeType === 'Suspend'
+              return (
+                <div key={step.id} className={clsx(
+                  'text-sm card-inner px-3 py-2',
+                  isFailed && 'border-l-2 border-red-500'
+                )}>
+                  <div className="flex items-center gap-2">
+                    <StepStatusIcon phase={step.phase} nodeType={step.nodeType} />
+                    <span className={clsx(
+                      'flex-1',
+                      isSkipped ? 'text-theme-text-tertiary' : isSuspend ? 'text-yellow-400' : 'text-theme-text-primary'
+                    )}>
+                      {step.displayName}
+                      {isSkipped && <span className="ml-1 text-xs text-theme-text-tertiary">(skipped)</span>}
+                      {isSuspend && <span className="ml-1 text-xs text-yellow-400/70">(suspend)</span>}
+                    </span>
+                    <span className="text-xs text-theme-text-secondary">{getStepDuration(step) || '-'}</span>
+                  </div>
+                  {isFailed && step.message && (
+                    <div className="text-xs text-red-400 mt-1 ml-6 break-all">{step.message}</div>
+                  )}
+                </div>
+              )
+            })}
           </div>
         </Section>
       )}

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

@@ -1,4 +1,4 @@
-import { Play, FileText, Key, Lock } from 'lucide-react'
+import { Play, FileText, Key, Lock, File, ArrowDownToLine, ArrowUpFromLine } from 'lucide-react'
 import { Section, PropertyList, Property } from '../../ui/drawer-components'
 
 interface WorkflowTemplateRendererProps {
@@ -44,6 +44,11 @@ export function WorkflowTemplateRenderer({ data }: WorkflowTemplateRendererProps
             {templates.map((template: any) => {
               const type = getTemplateType(template)
               const image = getTemplateImage(template)
+              const inputParams: Array<{ name: string }> = template.inputs?.parameters || []
+              const outputParams: Array<{ name: string }> = template.outputs?.parameters || []
+              const outputArtifacts: Array<{ name: string }> = template.outputs?.artifacts || []
+              const inputArtifacts: Array<{ name: string }> = template.inputs?.artifacts || []
+              const hasIO = inputParams.length > 0 || outputParams.length > 0 || outputArtifacts.length > 0 || inputArtifacts.length > 0
               return (
                 <div key={template.name} className="card-inner px-3 py-2 text-sm">
                   <div className="font-medium text-theme-text-primary">{template.name}</div>
@@ -53,6 +58,46 @@ export function WorkflowTemplateRenderer({ data }: WorkflowTemplateRendererProps
                       {image}
                     </div>
                   )}
+                  {hasIO && (
+                    <div className="mt-2 space-y-1.5">
+                      {(inputParams.length > 0 || inputArtifacts.length > 0) && (
+                        <div className="flex items-start gap-1.5">
+                          <ArrowDownToLine className="w-3 h-3 text-theme-text-tertiary mt-0.5 shrink-0" />
+                          <div className="flex flex-wrap gap-1">
+                            {inputParams.map((p) => (
+                              <span key={p.name} className="badge-sm bg-theme-elevated text-theme-text-secondary">
+                                {p.name}
+                              </span>
+                            ))}
+                            {inputArtifacts.map((a) => (
+                              <span key={a.name} className="badge-sm bg-theme-elevated text-theme-text-secondary flex items-center gap-0.5">
+                                <File className="w-2.5 h-2.5" />
+                                {a.name}
+                              </span>
+                            ))}
+                          </div>
+                        </div>
+                      )}
+                      {(outputParams.length > 0 || outputArtifacts.length > 0) && (
+                        <div className="flex items-start gap-1.5">
+                          <ArrowUpFromLine className="w-3 h-3 text-theme-text-tertiary mt-0.5 shrink-0" />
+                          <div className="flex flex-wrap gap-1">
+                            {outputParams.map((p) => (
+                              <span key={p.name} className="badge-sm bg-theme-elevated text-theme-text-secondary">
+                                {p.name}
+                              </span>
+                            ))}
+                            {outputArtifacts.map((a) => (
+                              <span key={a.name} className="badge-sm bg-theme-elevated text-theme-text-secondary flex items-center gap-0.5">
+                                <File className="w-2.5 h-2.5" />
+                                {a.name}
+                              </span>
+                            ))}
+                          </div>
+                        </div>
+                      )}
+                    </div>
+                  )}
                 </div>
               )
             })}

package/src/components/resources/renderers/karpenter-cells.tsx

@@ -3,6 +3,7 @@
 import { clsx } from 'clsx'
 import { Tooltip } from '../../ui/Tooltip'
 import {
+  CAPACITY_TYPE_BADGE,
   getNodePoolStatus,
   getNodePoolNodeClassRef,
   getNodePoolLimits,
@@ -22,9 +23,11 @@ export function NodePoolCell({ resource, column }: { resource: any; column: stri
     case 'status': {
       const status = getNodePoolStatus(resource)
       return (
-        <span className={clsx('badge', status.color)}>
-          {status.text}
-        </span>
+        <Tooltip content={status.text}>
+          <span className={clsx('badge truncate max-w-[140px]', status.color)}>
+            {status.text}
+          </span>
+        </Tooltip>
       )
     }
     case 'nodeClass': {
@@ -70,6 +73,18 @@ export function NodeClaimCell({ resource, column }: { resource: any; column: str
       const pool = getNodeClaimNodePoolRef(resource)
       return <span className="text-sm text-theme-text-secondary">{pool}</span>
     }
+    case 'capacityType': {
+      const ct = resource.metadata?.labels?.['karpenter.sh/capacity-type'] || '-'
+      return (
+        <span className={clsx('badge-sm', CAPACITY_TYPE_BADGE[ct] || '')}>
+          {ct}
+        </span>
+      )
+    }
+    case 'zone': {
+      const zone = resource.metadata?.labels?.['topology.kubernetes.io/zone'] || '-'
+      return <span className="text-sm text-theme-text-secondary">{zone}</span>
+    }
     default:
       return <span className="text-sm text-theme-text-tertiary">-</span>
   }

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

@@ -166,6 +166,43 @@ export function getCNPGClusterPostgresParams(resource: any): Record<string, stri
   return resource.spec?.postgresql?.parameters || {}
 }
 
+/** Per-instance replication state from status.instancesReportedState */
+export interface CNPGInstanceReportedState {
+  podName: string
+  isPrimary: boolean
+  timelineID?: number
+}
+
+export function getCNPGClusterInstancesReportedState(resource: any): CNPGInstanceReportedState[] {
+  const reported = resource.status?.instancesReportedState
+  if (!reported || typeof reported !== 'object') return []
+  return Object.entries(reported).map(([podName, state]: [string, any]) => ({
+    podName,
+    isPrimary: state?.isPrimary === true,
+    timelineID: state?.timelineID,
+  }))
+}
+
+/** Certificate expirations from status.certificates.expirations */
+export interface CNPGCertificateExpiry {
+  secretName: string
+  expiryDate: string
+  daysUntilExpiry: number
+}
+
+export function getCNPGClusterCertificateExpirations(resource: any): CNPGCertificateExpiry[] {
+  const expirations = resource.status?.certificates?.expirations
+  if (!expirations || typeof expirations !== 'object') return []
+  const now = new Date()
+  return Object.entries(expirations).map(([secretName, expiryDate]: [string, any]) => {
+    const expiry = new Date(expiryDate)
+    const daysUntilExpiry = isNaN(expiry.getTime())
+      ? -1  // treat unparseable dates as expired/critical
+      : Math.floor((expiry.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
+    return { secretName, expiryDate: String(expiryDate), daysUntilExpiry }
+  })
+}
+
 // ============================================================================
 // CNPG BACKUP UTILITIES
 // ============================================================================
@@ -342,3 +379,13 @@ export function getCNPGPoolerInstances(resource: any): string {
 export function getCNPGPoolerParameters(resource: any): Record<string, string> {
   return resource.spec?.pgbouncer?.parameters || {}
 }
+
+export function getCNPGPoolerAuthQuery(resource: any): string | undefined {
+  return resource.spec?.pgbouncer?.authQuery
+}
+
+export function getCNPGPoolerAuthQuerySecret(resource: any): { name: string } | undefined {
+  const secret = resource.spec?.pgbouncer?.authQuerySecret
+  if (!secret?.name) return undefined
+  return { name: secret.name }
+}

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

@@ -3,6 +3,12 @@
 import type { StatusBadge } from './resource-utils'
 import { healthColors } from './resource-utils'
 
+// Shared capacity type badge colors for NodeClaim renderer and table cells
+export const CAPACITY_TYPE_BADGE: Record<string, string> = {
+  spot: 'bg-amber-100 text-amber-800 border-amber-300 dark:bg-amber-950/50 dark:text-amber-400 dark:border-amber-700/40',
+  'on-demand': 'bg-sky-100 text-sky-700 border-sky-300 dark:bg-sky-950/50 dark:text-sky-400 dark:border-sky-700/40',
+}
+
 // ============================================================================
 // KARPENTER NODEPOOL UTILITIES
 // ============================================================================

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

@@ -99,23 +99,67 @@ export function getPrometheusRuleTotalRules(resource: any): number {
   return groups.reduce((sum: number, g: any) => sum + (g.rules?.length || 0), 0)
 }
 
-export function getPrometheusRuleGroups(resource: any): Array<{
+export interface PrometheusAlertRule {
+  type: 'alert'
+  alert: string
+  expr: string
+  for?: string
+  severity?: string
+  summary?: string
+  description?: string
+  labels?: Record<string, string>
+}
+
+export interface PrometheusRecordingRule {
+  type: 'recording'
+  record: string
+  expr: string
+  labels?: Record<string, string>
+}
+
+export type PrometheusRule = PrometheusAlertRule | PrometheusRecordingRule
+
+export interface PrometheusRuleGroup {
   name: string
   interval?: string
   ruleCount: number
   alertCount: number
   recordCount: number
-}> {
+  rules: PrometheusRule[]
+}
+
+export function getPrometheusRuleGroups(resource: any): PrometheusRuleGroup[] {
   return (resource.spec?.groups || []).map((g: any) => {
-    const rules = g.rules || []
-    const alertCount = rules.filter((r: any) => r.alert).length
-    const recordCount = rules.filter((r: any) => r.record).length
+    const rawRules = g.rules || []
+    const alertCount = rawRules.filter((r: any) => r.alert).length
+    const recordCount = rawRules.filter((r: any) => r.record).length
+    const rules: PrometheusRule[] = rawRules.map((r: any) => {
+      if (r.alert) {
+        return {
+          type: 'alert' as const,
+          alert: r.alert,
+          expr: r.expr || '',
+          for: r.for,
+          severity: r.labels?.severity,
+          summary: r.annotations?.summary,
+          description: r.annotations?.description,
+          labels: r.labels,
+        }
+      }
+      return {
+        type: 'recording' as const,
+        record: r.record || '',
+        expr: r.expr || '',
+        labels: r.labels,
+      }
+    })
     return {
       name: g.name,
       interval: g.interval,
-      ruleCount: rules.length,
+      ruleCount: rawRules.length,
       alertCount,
       recordCount,
+      rules,
     }
   })
 }

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

@@ -42,6 +42,44 @@ export interface PodProblem {
   message: string
 }
 
+/** Tailwind classes for severity dot indicators (used in tooltips and alert banners) */
+export const SEVERITY_DOT_COLOR: Record<PodProblem['severity'], string> = {
+  critical: 'bg-red-400',
+  high: 'bg-orange-400',
+  medium: 'bg-yellow-400',
+}
+
+/** Check whether a pod's problems match a given problem category (filter chip label) */
+export function podMatchesProblemCategory(problems: PodProblem[], restarts: number, category: string): boolean {
+  const msgs = problems.map(p => p.message)
+  switch (category) {
+    case 'CrashLoopBackOff':
+      return msgs.includes('CrashLoopBackOff')
+    case 'ImagePullBackOff':
+      return msgs.some(m => m.includes('ImagePull') && !m.startsWith('Init:'))
+    case 'OOMKilled':
+      return msgs.includes('OOMKilled')
+    case 'Unschedulable':
+      return msgs.includes('Unschedulable')
+    case 'Not Ready':
+      return msgs.includes('Not Ready') || msgs.some(m => m.includes('Probe'))
+    case 'High Restarts':
+      return restarts > 5
+    case 'Init Failed':
+      return msgs.some(m => m.startsWith('Init:'))
+    case 'Exit Code Error':
+      return msgs.some(m => m.startsWith('Exit Code'))
+    case 'Failed':
+      return msgs.includes('Failed') || msgs.includes('Unknown')
+    case 'Other': {
+      const knownPatterns = ['CrashLoopBackOff', 'ImagePull', 'ErrImagePull', 'OOMKilled', 'Unschedulable', 'Not Ready', 'Probe', 'Init:', 'Exit Code', 'Failed', 'Unknown']
+      return problems.some(p => !knownPatterns.some(pat => p.message.includes(pat)) && p.message !== `${restarts} restarts`)
+    }
+    default:
+      return false
+  }
+}
+
 export function getPodStatus(pod: any): StatusBadge {
   const phase = pod.status?.phase || 'Unknown'
   const containerStatuses = pod.status?.containerStatuses || []
@@ -87,7 +125,31 @@ export function getPodStatus(pod: any): StatusBadge {
 export function getPodProblems(pod: any): PodProblem[] {
   const problems: PodProblem[] = []
   const containerStatuses = pod.status?.containerStatuses || []
+  const initContainerStatuses = pod.status?.initContainerStatuses || []
   const conditions = pod.status?.conditions || []
+  const phase = pod.status?.phase
+
+  // Failed or Unknown phase
+  if (phase === 'Failed' && pod.status?.reason !== 'Evicted') {
+    problems.push({ severity: 'critical', message: 'Failed' })
+  } else if (phase === 'Unknown') {
+    problems.push({ severity: 'high', message: 'Unknown' })
+  }
+
+  // Init container failures
+  for (const cs of initContainerStatuses) {
+    if (cs.state?.waiting?.reason && cs.state.waiting.reason !== 'PodInitializing') {
+      const reason = cs.state.waiting.reason
+      if (['CrashLoopBackOff', 'ImagePullBackOff', 'ErrImagePull'].includes(reason)) {
+        problems.push({ severity: 'critical', message: `Init: ${reason}` })
+      } else {
+        problems.push({ severity: 'high', message: `Init: ${reason}` })
+      }
+    }
+    if (cs.state?.terminated?.exitCode && cs.state.terminated.exitCode !== 0) {
+      problems.push({ severity: 'high', message: `Init: Exit Code ${cs.state.terminated.exitCode}` })
+    }
+  }
 
   for (const cs of containerStatuses) {
     // Check waiting state
@@ -99,11 +161,15 @@ export function getPodProblems(pod: any): PodProblem[] {
         problems.push({ severity: 'critical', message: 'Config Error' })
       } else if (reason === 'ContainerCannotRun') {
         problems.push({ severity: 'critical', message: 'Cannot Run' })
+      } else if (reason !== 'ContainerCreating' && reason !== 'PodInitializing') {
+        problems.push({ severity: 'high', message: reason })
       }
     }
     // Check terminated state
     if (cs.state?.terminated?.reason === 'OOMKilled') {
       problems.push({ severity: 'critical', message: 'OOMKilled' })
+    } else if (cs.state?.terminated?.exitCode && cs.state.terminated.exitCode !== 0) {
+      problems.push({ severity: 'high', message: `Exit Code ${cs.state.terminated.exitCode}` })
     }
     // High restart count
     if (cs.restartCount > 5) {
@@ -142,7 +208,7 @@ export function getPodProblems(pod: any): PodProblem[] {
   }
 
   // Evicted pods
-  if (pod.status?.phase === 'Failed' && pod.status?.reason === 'Evicted') {
+  if (phase === 'Failed' && pod.status?.reason === 'Evicted') {
     problems.push({ severity: 'high', message: 'Evicted' })
   }
 
@@ -156,7 +222,6 @@ export function getPodProblems(pod: any): PodProblem[] {
   }
 
   // Not ready (Running but containers not ready)
-  const phase = pod.status?.phase
   if (phase === 'Running') {
     const readyContainers = containerStatuses.filter((c: any) => c.ready).length
     const totalContainers = containerStatuses.length
@@ -335,6 +400,70 @@ export function getWorkloadStatus(resource: any, kind: string): StatusBadge {
   return { text: `${ready}/${desired}`, color: healthColors.unhealthy, level: 'unhealthy' }
 }
 
+/** Detect problems for Deployments, StatefulSets, DaemonSets. Parallel to getPodProblems. */
+export function getWorkloadProblems(resource: any, kind: string): PodProblem[] {
+  const problems: PodProblem[] = []
+  const status = resource.status || {}
+  const spec = resource.spec || {}
+  const k = kind.toLowerCase()
+
+  if (k === 'daemonsets') {
+    const desired = status.desiredNumberScheduled || 0
+    const ready = status.numberReady || 0
+    if (desired > 0 && ready === 0) {
+      problems.push({ severity: 'critical', message: 'No pods ready' })
+    } else if (desired > 0 && ready < desired) {
+      problems.push({ severity: 'high', message: `${desired - ready} pods unavailable` })
+    }
+    return problems
+  }
+
+  // Deployment, StatefulSet
+  const desired = spec.replicas ?? status.replicas ?? 0
+  const ready = status.readyReplicas || 0
+  const available = status.availableReplicas ?? ready
+  const updated = status.updatedReplicas || 0
+
+  if (desired === 0) return problems
+
+  if (ready === 0 && desired > 0) {
+    problems.push({ severity: 'critical', message: 'No pods ready' })
+  } else if (available < desired) {
+    problems.push({ severity: 'high', message: `${desired - available} pods unavailable` })
+  }
+
+  if (updated > 0 && updated < desired) {
+    problems.push({ severity: 'medium', message: 'Rollout in progress' })
+  }
+
+  // Check conditions for stuck rollouts (Deployment only)
+  if (k === 'deployments') {
+    const conditions = status.conditions || []
+    for (const cond of conditions) {
+      if (cond.type === 'Progressing' && cond.status === 'False' && cond.reason === 'ProgressDeadlineExceeded') {
+        problems.push({ severity: 'critical', message: 'Rollout stuck' })
+      }
+    }
+  }
+
+  return problems
+}
+
+/** Check whether a workload's problems match a given problem category */
+export function workloadMatchesProblemCategory(problems: PodProblem[], category: string): boolean {
+  const msgs = problems.map(p => p.message)
+  switch (category) {
+    case 'Unavailable':
+      return msgs.some(m => m.includes('unavailable') || m.includes('No pods ready'))
+    case 'Rollout Stuck':
+      return msgs.includes('Rollout stuck')
+    case 'Rollout In Progress':
+      return msgs.includes('Rollout in progress')
+    default:
+      return false
+  }
+}
+
 export function getWorkloadImages(resource: any): string[] {
   const containers = resource.spec?.template?.spec?.containers || []
   return containers.map((c: any) => {
@@ -1325,37 +1454,6 @@ export function getRoleBindingSubjectCount(rb: any): number {
 // WORKLOAD PROBLEM DETECTION (for table row indicators)
 // ============================================================================
 
-export function getWorkloadProblems(resource: any, kind: string): string[] {
-  const problems: string[] = []
-  const status = resource.status || {}
-  const spec = resource.spec || {}
-
-  if (kind === 'daemonsets') {
-    const ready = status.numberReady || 0
-    const desired = status.desiredNumberScheduled || 0
-    if (desired > 0 && ready < desired) {
-      problems.push(`${desired - ready} pods not ready`)
-    }
-  } else {
-    const ready = status.readyReplicas || 0
-    const desired = spec.replicas ?? 0
-    if (desired > 0 && ready < desired) {
-      problems.push(`${desired - ready} replicas not ready`)
-    }
-  }
-
-  const conditions = status.conditions || []
-  for (const cond of conditions) {
-    if (cond.status === 'True' && cond.type === 'ReplicaFailure') {
-      problems.push('ReplicaFailure')
-    }
-    if (cond.status === 'False' && cond.type === 'Available') {
-      problems.push('Unavailable')
-    }
-  }
-
-  return problems
-}
 
 // ============================================================================
 // FORMATTING UTILITIES