@skyhook-io/k8s-ui 1.17.0 → 1.18.0

package/src/components/issues/ConditionalCleanup.test.tsx

@@ -0,0 +1,82 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { expect, it, vi } from 'vitest'
+import { IssueRow } from './IssuesView'
+import type { Issue } from './types'
+
+vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
+
+const condition =
+  'If victoria-metrics-operator was uninstalled on purpose (and nothing else should finalize this object), remove the finalizer'
+const kubectl = `kubectl patch 'vmagents.operator.victoriametrics.com' 'stuck' -n 'team' --type=json -p '[]' --dry-run=server`
+
+const issue: Issue = {
+  id: 'vmagent-stuck',
+  severity: 'warning',
+  source: 'problem',
+  category: 'termination_stuck',
+  category_group: 'control_plane',
+  grouping_scope: 'unknown',
+  group: 'operator.victoriametrics.com',
+  kind: 'VMAgent',
+  namespace: 'team',
+  name: 'stuck',
+  reason: 'Terminating stuck',
+  cause: 'Deletion has been pending for 2h.',
+  action:
+    'No recognized controller found for finalizer "apps.victoriametrics.com/finalizer". If victoria-metrics-operator should be running, restore it so it can resume cleanup.',
+  conditional_cleanup: {
+    condition,
+    agent_guidance: 'Not the next step.',
+    caution: 'Removing a finalizer skips the cleanup its controller would have done.',
+    removals: [
+      {
+        finalizer: 'apps.victoriametrics.com/finalizer',
+        patch_resource: { kind: 'VMAgent', name: 'stuck', dry_run: true },
+        kubectl,
+      },
+    ],
+  },
+}
+
+it('keeps a conditional cleanup closed behind its condition, apart from the next step', async () => {
+  const element = document.createElement('div')
+  const root = createRoot(element)
+  await act(async () => {
+    root.render(<IssueRow issue={issue} open onToggle={() => {}} />)
+  })
+
+  const toggle = [...element.querySelectorAll('button')].find((button) => button.textContent?.includes(condition))
+  expect(toggle, 'the toggle is labeled with the condition').toBeTruthy()
+  expect(toggle!.getAttribute('aria-expanded')).toBe('false')
+  const panel = [...element.querySelectorAll<HTMLElement>('[id]')].find((node) => node.id === toggle!.getAttribute('aria-controls'))!
+  expect(panel.style.gridTemplateRows).toBe('0fr')
+  expect(panel.firstElementChild!.hasAttribute('inert')).toBe(true)
+  expect(panel.textContent).toContain(kubectl)
+
+  const nextStep = [...element.querySelectorAll('section')].find((section) => section.querySelector('h4')?.textContent === 'Next step')
+  expect(nextStep?.textContent).toContain('restore it')
+  expect(nextStep?.textContent).not.toContain('kubectl')
+  expect(nextStep?.textContent).not.toContain('patch_resource')
+  expect(nextStep?.contains(toggle!)).toBe(false)
+
+  await act(async () => {
+    toggle!.click()
+  })
+  expect(toggle!.getAttribute('aria-expanded')).toBe('true')
+  expect(panel.style.gridTemplateRows).toBe('1fr')
+  expect(panel.firstElementChild!.hasAttribute('inert')).toBe(false)
+
+  await act(async () => root.unmount())
+})
+
+it('renders no cleanup section when the issue has none', async () => {
+  const element = document.createElement('div')
+  const root = createRoot(element)
+  await act(async () => {
+    root.render(<IssueRow issue={{ ...issue, conditional_cleanup: undefined }} open onToggle={() => {}} />)
+  })
+  expect(element.textContent).not.toContain('Conditional cleanup')
+  await act(async () => root.unmount())
+})

package/src/components/issues/IssuesView.tsx

@@ -1,6 +1,7 @@
+import { summarizeSchedulerMessage } from '../resources/resource-utils'
 import { useMemo, useState, type ComponentType, type ReactNode } from 'react';
-import { AlertOctagon, AlertTriangle, ArrowRight, CircleCheck, Clock, ExternalLink, Layers, Terminal, Workflow } from 'lucide-react';
-import { CardBody, CardSection, ClusterName, EmptyState, KIND_CHIP_CLASS, TerminalBlock } from '../ui';
+import { AlertOctagon, AlertTriangle, ArrowRight, CircleCheck, Clock, Eraser, ExternalLink, Layers, Terminal, Workflow } from 'lucide-react';
+import { CardBody, CardSection, ClusterName, Disclosure, EmptyState, KIND_CHIP_CLASS, TerminalBlock } from '../ui';
 import { Collapse, CollapseChevron, useDisclosure } from '../ui/Collapse';
 import { Tooltip } from '../ui/Tooltip';
 import { formatCompactAge, formatRelativeAgeTime } from '../../utils/format';
@@ -13,7 +14,7 @@ import {
   ISSUE_SEVERITY_RAIL_CLASS,
   ISSUE_SEVERITY_SOLID_CLASS,
   ISSUE_SEVERITY_TEXT_CLASS,
-  categoryLabel,
+  issueTitle,
   groupBadgeClass,
   groupLabel,
 } from './severity';
@@ -24,6 +25,7 @@ import {
   subjectRef,
   type Issue,
   type IssueAffected,
+  type IssueConditionalCleanup,
   type IssueResourceRef,
   type IssueSeverity,
 } from './types';
@@ -168,6 +170,7 @@ export interface IssueRowProps {
   resourceHref?: (ref: IssueResourceRef) => string;
   onResourceClick?: (ref: IssueResourceRef) => void;
   as?: 'li' | 'div';
+  compact?: boolean;
   className?: string;
   dimmed?: boolean;
   /** Suppress the "Subject" deep-link in the expanded body — set by hosts that
@@ -195,6 +198,7 @@ export function IssueRow({
   resourceHref,
   onResourceClick,
   as = 'li',
+  compact = false,
   className,
   dimmed,
   hideSubject,
@@ -208,6 +212,7 @@ export function IssueRow({
   const cluster = clusterLabel?.(issue);
   const affected = affectedSummary(issue.affected);
   const { headline } = issueMessageParts(issue);
+  const schedulingCause = compact && issue.reason === 'Unschedulable' ? summarizeSchedulerMessage(issue.cause || issue.message || headline || '', { plain: true }) : undefined;
   const { panelId, buttonProps } = useDisclosure(open);
   const Container = as;
   const severity = normalizeIssueSeverity(issue.severity);
@@ -289,7 +294,7 @@ export function IssueRow({
 
         <div className="flex min-w-0 flex-1 flex-col gap-1">
           <div className="flex min-w-0 items-baseline gap-2">
-            <span className="min-w-0 truncate text-sm font-medium text-theme-text-primary">{categoryLabel(issue.category)}</span>
+            <span className="min-w-0 truncate text-sm font-medium text-theme-text-primary">{issueTitle(issue)}</span>
             <span className={`shrink-0 self-center ${groupBadgeClass(issue.category_group)}`}>{groupLabel(issue.category_group)}</span>
             {renderBadges?.(slotCtx)}
             {/* The detector reason rides the title row while COLLAPSED so the
@@ -297,7 +302,7 @@ export function IssueRow({
                 cause lives in the WHAT'S WRONG section below, so it fades out
                 here (stays mounted — it's the flex-1 filler, so unmounting
                 wouldn't reflow anything, but fading avoids the pop). */}
-            {issue.reason ? (
+            {issue.reason && !schedulingCause ? (
               <span
                 aria-hidden={open || undefined}
                 className={`min-w-0 flex-1 truncate text-xs text-theme-text-tertiary transition-opacity duration-200 ${open ? 'opacity-0' : 'opacity-100'}`}
@@ -307,6 +312,7 @@ export function IssueRow({
               </span>
             ) : null}
           </div>
+          {schedulingCause && <div className="break-words text-xs text-theme-text-secondary">{schedulingCause}</div>}
           <div className="flex min-w-0 items-center gap-1.5 text-xs text-theme-text-tertiary">
             <span className={KIND_CHIP_CLASS}>{issue.kind}</span>
             <span className="min-w-0 truncate font-medium text-theme-text-secondary">
@@ -429,9 +435,12 @@ function Diagnosis({ issue, source }: { issue: Issue; source?: IssueDiagnosisSou
   const partialUnknown = issue.onset_coverage?.unknown ?? 0;
   const partialOnset = Boolean(issue.first_seen && partialUnknown > 0);
   const timing = issueTimingForDisplay(issue);
+  // A message Radar wrote itself is not raw output, so it never lands in the
+  // terminal block; its cause carries the same facts.
+  const messageIsRaw = issue.message_source !== 'radar';
   const rawError = [
     ...new Set(
-      [issue.raw_message ?? (issue.cause ? issue.message : undefined), detail].filter(
+      [issue.raw_message ?? (issue.cause && messageIsRaw ? issue.message : undefined), detail].filter(
         (s): s is string => !!s && s !== shownText,
       ),
     ),
@@ -544,6 +553,8 @@ function Diagnosis({ issue, source }: { issue: Issue; source?: IssueDiagnosisSou
         </CardSection>
       ) : null}
 
+      {issue.conditional_cleanup ? <ConditionalCleanup cleanup={issue.conditional_cleanup} /> : null}
+
       {rawError ? (
         <CardSection icon={Terminal} label="Raw error">
           <TerminalBlock>{rawError}</TerminalBlock>
@@ -553,6 +564,33 @@ function Diagnosis({ issue, source }: { issue: Issue; source?: IssueDiagnosisSou
   );
 }
 
+// A step that is right only under its condition. It stays closed behind the
+// condition so the row's next step remains the default path, and it is not
+// toned as a fix.
+function ConditionalCleanup({ cleanup }: { cleanup: IssueConditionalCleanup }) {
+  return (
+    <CardSection icon={Eraser} label="Conditional cleanup">
+      <Disclosure
+        summary={<span className="text-sm leading-relaxed">{cleanup.condition}</span>}
+        summaryClassName="items-baseline text-theme-text-primary hover:text-theme-text-secondary"
+      >
+        <div className="flex flex-col gap-2 pt-2">
+          {cleanup.caution ? <p className="text-xs leading-relaxed text-theme-text-secondary">{cleanup.caution}</p> : null}
+          {cleanup.removals.map((removal) => (
+            <div key={removal.finalizer} className="flex flex-col gap-1.5">
+              <p className="text-xs text-theme-text-tertiary">
+                Finalizer <code className="inline-code">{removal.finalizer}</code>
+              </p>
+              <TerminalBlock label="patch_resource · dry run">{JSON.stringify(removal.patch_resource)}</TerminalBlock>
+              <TerminalBlock label="kubectl · server dry run">{removal.kubectl}</TerminalBlock>
+            </div>
+          ))}
+        </div>
+      </Disclosure>
+    </CardSection>
+  );
+}
+
 function changeContextText(change: NonNullable<Issue['change_context']>): string {
   const parts = [change.when ? `Changed ${change.when} ago` : 'Changed', change.what ? change.what.replace(/_/g, ' ') : null, change.evidence].filter(Boolean);
   return parts.join(' · ');

package/src/components/issues/ResourceIssuesSection.test.tsx

@@ -106,3 +106,31 @@ it('keeps pod/template evidence in expanded neutral context with navigable witne
   expect(expanded).not.toContain('confidence')
   expect(expanded).not.toContain('Caused by')
 })
+
+it('wraps a compact Pod scheduling cause separately and retains the full message in details', () => {
+  const raw = '0/2 nodes are available: 2 Too many pods. preemption: 0/2 nodes are available: 2 No preemption victims found for incoming pod.'
+  const pod: Issue = { ...issue, kind: 'Pod', reason: 'Unschedulable', cause: raw, message: raw }
+  const html = renderToString(<IssueRow issue={pod} compact open onToggle={() => {}} />)
+  expect(html).toContain('break-words text-xs text-theme-text-secondary')
+  expect(html).toContain('both nodes have reached their Pod limit')
+  expect(html).toContain(raw)
+  const producerMessage = '2 node(s) insufficient pods (0/2 nodes available)'
+  const reported = renderToString(<IssueRow issue={{ ...pod, cause: undefined, message: producerMessage }} compact open onToggle={() => {}} />)
+  expect(reported).toContain('both nodes have reached their Pod limit')
+  expect(reported).toContain(producerMessage)
+  const regular = renderToString(<IssueRow issue={pod} open={false} onToggle={() => {}} />)
+  expect(regular).not.toContain('both nodes have reached their Pod limit')
+})
+
+it.each(['Cluster', 'Deployment'])('wraps compact scheduling causes aggregated under %s', (kind) => {
+  const raw = '2 node(s) insufficient pods (0/2 nodes available)'
+  const aggregated: Issue = { ...issue, kind, reason: 'Unschedulable', cause: raw, message: raw }
+  const collapsed = renderToString(<IssueRow issue={aggregated} compact open={false} onToggle={() => {}} />)
+  expect(collapsed).toContain('<div class="break-words text-xs text-theme-text-secondary">both nodes have reached their Pod limit</div>')
+  expect(collapsed).not.toContain(raw)
+  const expanded = renderToString(<IssueRow issue={aggregated} compact open onToggle={() => {}} />)
+  expect(expanded).toContain(raw)
+  const regular = renderToString(<IssueRow issue={aggregated} open={false} onToggle={() => {}} />)
+  expect(regular).toContain('Unschedulable')
+  expect(regular).not.toContain('both nodes have reached their Pod limit')
+})

package/src/components/issues/ResourceIssuesSection.tsx

@@ -1,14 +1,18 @@
-import { useMemo, useState } from 'react'
+import { useMemo, useState, type ReactNode } from 'react'
 import { AlertTriangle } from 'lucide-react'
 import { kindToPluralWithGroup } from '../../utils/navigation'
-import { IssueRow } from './IssuesView'
+import { IssueRow, type IssueRowSlotContext } from './IssuesView'
 import { compareIssues, subjectRef, type Issue, type IssueResourceRef } from './types'
 
 export function ResourceIssuesSection({
   issues,
   onResourceClick,
   subjectResource,
+  compact,
+  renderDetailSection,
 }: {
+  compact?: boolean
+  renderDetailSection?: (ctx: IssueRowSlotContext) => ReactNode
   issues: Issue[] | undefined
   /** When provided, related resources in a causal link become clickable. */
   onResourceClick?: (ref: IssueResourceRef) => void
@@ -36,6 +40,8 @@ export function ResourceIssuesSection({
             <IssueRow
               key={key}
               issue={issue}
+              compact={compact}
+              renderDetailSection={renderDetailSection}
               open={openId === key}
               onToggle={() => setOpenId((cur) => (cur === key ? null : key))}
               onResourceClick={onResourceClick}

package/src/components/issues/diagnostic.ts

@@ -52,6 +52,8 @@ export function diagnosticFactLabel(type: string): string {
       return 'Dependent pods';
     case 'admission_webhook_backend':
       return 'Admission dependency';
+    case 'network_policy_isolates':
+      return 'Affected resources';
     default:
       return type.replace(/_/g, ' ');
   }

package/src/components/issues/index.ts

@@ -16,7 +16,7 @@ export {
   issueSortAnchor,
   compareIssueSortAnchors,
 } from './types';
-export type { Issue, IssueSeverity, IssueAffected, IssueResourceRef, IssueDiagnosticContext, IssueDiagnosticFact, IssueDiagnosticConfidence, IssueDiagnosticIssueRef, IssueDiagnosticRole, IssueIncidentParent, IssueChangeContext, IssueRecentChange, IssueRecentChangeField } from './types';
+export type { Issue, IssueConditionalCleanup, IssueFinalizerRemoval, IssueSeverity, IssueAffected, IssueResourceRef, IssueDiagnosticContext, IssueDiagnosticFact, IssueDiagnosticConfidence, IssueDiagnosticIssueRef, IssueDiagnosticRole, IssueIncidentParent, IssueChangeContext, IssueRecentChange, IssueRecentChangeField, IssueRunningPreviousValue, IssueWithheld } from './types';
 export {
   ISSUE_SEVERITY_LABEL,
   ISSUE_SEVERITY_BADGE_CLASS,
@@ -24,5 +24,7 @@ export {
   ISSUE_SEVERITY_FILL_CLASS,
   ISSUE_SEVERITY_RAIL_CLASS,
   categoryLabel,
+  issueTitle,
+  issueReasonTitle,
   groupLabel,
 } from './severity';

package/src/components/issues/issue-timing.ts

@@ -1,7 +1,7 @@
 import { isDeploymentLikeWorkloadKind } from '../../types';
 import type { Issue } from './types';
 
-export type IssueTimingDisplayKind = 'creation' | 'regression';
+export type IssueTimingDisplayKind = 'creation' | 'regression' | 'deletion';
 
 export interface IssueTimingDisplay {
   kind: IssueTimingDisplayKind;
@@ -77,6 +77,17 @@ export function issueTiming(issue: Issue): IssueTimingDisplay | null {
   const grouped = (coverage?.known ?? 0) + (coverage?.unknown ?? 0) > 1;
   const uncertaintyMeta = onsetUncertaintyMeta(issue);
   const uncertaintyTooltip = onsetUncertaintyTooltip(issue);
+  // A stuck deletion is timed from its deletionTimestamp. The creation-vs-healthy
+  // classification only says whether the object was deleted soon after it was
+  // created, which is not what the age beside this chip measures.
+  if (issue.issue_timing_basis === 'deletion' && issue.issue_timing) {
+    return {
+      kind: 'deletion',
+      chip: 'since deletion',
+      meta: 'pending since deletion was requested',
+      tooltip: 'Timed from when deletion was requested; the object is still present.',
+    };
+  }
   switch (issue.issue_timing) {
     case 'started_after_resource_was_healthy': {
       if (issue.issue_timing_basis === 'owner_condition') {

package/src/components/issues/issues.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, it, expect, vi } from 'vitest'
 import { createElement } from 'react'
 import { renderToString } from 'react-dom/server'
 import { compareIssues, issueSortAnchor, subjectRef, memberRef, normalizeImagePullMessage, issueMessageParts, type Issue } from './types'
-import { categoryLabel, groupBadgeClass, groupLabel } from './severity'
+import { categoryLabel, groupBadgeClass, groupLabel, issueTitle } from './severity'
 import { IssueRow } from './IssuesView'
 import { issueFirstSeenTitle, issueResourceCreatedTitle, issueTiming } from './issue-timing'
 
@@ -83,6 +83,8 @@ describe('category/group label fallbacks', () => {
   it('returns the mapped label, else humanizes (server-added category needs no frontend deploy)', () => {
     expect(categoryLabel('crashloop')).toBe('Crash loop')
     expect(categoryLabel('some_new_future_category')).toBe('Some new future category')
+    expect(issueTitle({ category: 'backup_failed', reason: 'CNPGWALArchivingFailing' })).toBe('WAL archiving failing')
+    expect(issueTitle({ category: 'backup_failed', reason: 'BackupFailed' })).toBe('Backup failed')
   })
   it('humanizes an unmapped group', () => {
     expect(groupLabel('runtime')).toBe('Runtime')
@@ -137,6 +139,33 @@ describe('IssueRow', () => {
     expect(html).toContain('after healthy')
   })
 
+  it('labels a stuck deletion by how long deletion has been pending', () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-06-30T12:00:00Z'))
+
+    const html = renderToString(createElement(IssueRow, {
+      issue: mk({
+        id: 'terminating',
+        kind: 'VMAgent',
+        group: 'operator.victoriametrics.com',
+        category: 'termination_stuck',
+        category_group: 'control_plane',
+        reason: 'Terminating stuck',
+        first_seen: '2026-06-30T11:30:00Z',
+        issue_timing: 'started_at_resource_creation',
+        issue_timing_basis: 'deletion',
+      }),
+      open: true,
+      onToggle: () => undefined,
+    }))
+
+    expect(html).toContain('30m')
+    expect(html).toContain('since deletion')
+    expect(html).toContain('pending since deletion was requested')
+    expect(html).not.toContain('since creation')
+    expect(html).not.toContain('first reconciliation')
+  })
+
   it('uses the category-group chip class in the queue row', () => {
     const html = renderToString(createElement(IssueRow, {
       issue: mk({ category_group: 'control_plane', kind: 'Node' }),
@@ -394,6 +423,25 @@ describe('issueTiming', () => {
     })
   })
 
+  it('times stuck deletions from the deletion request, however soon after creation it came', () => {
+    for (const timing of ['started_at_resource_creation', 'started_after_resource_was_healthy'] as const) {
+      for (const kind of ['Pod', 'VMAgent']) {
+        const display = issueTiming(mk({
+          kind,
+          category: 'termination_stuck',
+          issue_timing: timing,
+          issue_timing_basis: 'deletion',
+        }))
+        expect(display).toMatchObject({
+          kind: 'deletion',
+          chip: 'since deletion',
+          meta: 'pending since deletion was requested',
+        })
+        expect(`${display?.chip} ${display?.meta} ${display?.tooltip}`).not.toMatch(/creation|healthy|deploy/i)
+      }
+    }
+  })
+
   it('describes direct after-healthy timing without coupling it to first_seen', () => {
     const display = issueTiming(mk({
       first_seen: '2026-06-30T10:00:00Z',
@@ -489,4 +537,30 @@ describe('IssueRow diagnosis raw messages', () => {
     expect(html).toContain('app path does not exist')
     expect(html).toContain('rpc error: code = Unknown desc = app path does not exist')
   })
+
+  it("doesn't present Radar's own summary as a raw error", () => {
+    const base = {
+      category: 'network_policy_denied',
+      category_group: 'networking',
+      severity: 'warning' as const,
+      reason: 'NetworkPolicy denies all ingress',
+      message: 'Would block all inbound traffic to the 2 pods behind Service recommendation',
+      cause: 'NetworkPolicy deny-all leaves the 2 pods behind Service recommendation with no allowed inbound traffic.',
+    }
+    const radar = renderToString(createElement(IssueRow, {
+      issue: mk({
+        ...base,
+        message_source: 'radar',
+        diagnostic_context: { role: 'candidate', facts: [{ type: 'network_policy_isolates', confidence: 'high', refs: [{ kind: 'Service', namespace: 'shop', name: 'recommendation' }] }] },
+      }),
+      open: true, onToggle: () => undefined, as: 'div',
+    }))
+    expect(radar).not.toContain('Raw error')
+    expect(radar).toContain('leaves the 2 pods behind Service recommendation')
+    expect(radar).toContain('Affected resources')
+
+    // Without the marker the message is still treated as detector output.
+    const unmarked = renderToString(createElement(IssueRow, { issue: mk(base), open: true, onToggle: () => undefined, as: 'div' }))
+    expect(unmarked).toContain('Raw error')
+  })
 })

package/src/components/issues/severity.ts

@@ -70,13 +70,14 @@ const CATEGORY_LABEL: Record<string, string> = {
   pdb_blocks_evictions: 'Evictions blocked',
   secret_sync_failed: 'Secret sync failed',
   service_no_endpoints: 'No endpoints',
+  service_mixed_backends: 'Mixed Service backends',
   ingress_backend_missing: 'Ingress backend missing',
   ingress_class_missing: 'Ingress class missing',
   load_balancer_pending: 'Load balancer pending',
   gateway_not_ready: 'Gateway not ready',
   gateway_route_invalid: 'Gateway route invalid',
   dns_failure: 'DNS failure',
-  network_policy_block: 'Network policy block',
+  network_policy_denied: 'Traffic denied by NetworkPolicy',
   pvc_pending: 'PVC pending',
   pvc_lost: 'PVC lost',
   pv_failed: 'PV failed',
@@ -87,7 +88,7 @@ const CATEGORY_LABEL: Record<string, string> = {
   backup_target_unavailable: 'Backup target unavailable',
   backup_stalled: 'Backup not progressing',
   job_failed: 'Job failed',
-  cronjob_failed: 'CronJob failed',
+  cronjob_failed: 'CronJob needs attention',
   rollout_stalled: 'Rollout stalled',
   hpa_limited_or_failed: 'Autoscaling limited',
   rbac_forbidden: 'Permission denied',
@@ -136,6 +137,33 @@ export function categoryLabel(category: string): string {
   return CATEGORY_LABEL[category] ?? humanize(category);
 }
 
+// Reasons filed under a category whose label names a different operation:
+// CNPG archiving and an unanswered scheduled run sit under backup_failed.
+const REASON_TITLE: Record<string, string> = {
+  InvalidSchedule: 'Scheduling error reported',
+  UnparseableSchedule: 'Scheduling error reported',
+  UnParseableCronJobSchedule: 'Scheduling error reported',
+  UnknownTimeZone: 'Time zone error reported',
+  MissSchedule: 'Missed schedule reported',
+  TooManyMissedTimes: 'Missed schedules reported',
+  CNPGWALArchivingFailing: "WAL archiving failing",
+  CNPGLastBackupFailed: "Latest backup failed",
+  CNPGScheduleDestinationMissing: "Backup schedule has no destination",
+  CNPGInstanceReadinessMismatch: "Instance Pods contradict Cluster readiness",
+  CNPGPrimaryLabelMismatch: "Primary Pod label contradicts Cluster status",
+  CNPGScheduledRunNoBackup: "No successful backup since a scheduled run",
+};
+
+/** The title a reason has wherever it is shown, when its category's label would name the wrong operation. */
+export function issueReasonTitle(reason: string | undefined): string | undefined {
+  return reason ? REASON_TITLE[reason] : undefined;
+}
+
+/** An issue row's title: its category, unless the reason names it better. */
+export function issueTitle(issue: { category: string; reason?: string }): string {
+  return issueReasonTitle(issue.reason) || categoryLabel(issue.category);
+}
+
 export function groupLabel(group: string): string {
   return GROUP_LABEL[group] ?? humanize(group);
 }

package/src/components/issues/types.ts

@@ -118,6 +118,23 @@ export interface IssueRecentChangeField {
   newValue?: unknown;
 }
 
+/** Names the caller's access kept out of a list, counted but never named. */
+export interface IssueWithheld {
+  count: number;
+  /** A readreason code; always "user_forbidden" today. */
+  reason: string;
+}
+
+export interface IssueRunningPreviousValue {
+  /** Owners the caller may read, capped at 5. */
+  workloads: string[] | null;
+  /** Owners left out because the caller may not read them. */
+  withheld?: IssueWithheld;
+  pods: number;
+  keys: string[];
+  note: string;
+}
+
 export interface IssueRecentChange {
   source?: string;
   kind: string;
@@ -130,15 +147,39 @@ export interface IssueRecentChange {
   timestamp: string;
   change_category?: 'spec_config' | 'lifecycle' | 'runtime_status' | string;
   rank_reason?: string;
-  /** Ranking hint for workload runtime configuration (including the image) or directly consumed ConfigMap data; not a causal claim. */
+  /** Ranking hint for workload runtime configuration (including the image), directly referenced ConfigMap data, or Secret writes with likely-stale env readers; not a causal claim. */
   application_configuration_change?: boolean;
   /** Set only on top-level recent_changes in an eligible, unfiltered issues response with complete linkage evidence. */
   not_linked_to_returned_issues?: boolean;
   fields?: IssueRecentChangeField[];
-  /** Workloads that mount/reference this ConfigMap directly ("Deployment/flagd").
-   *  Direct spec references only — runtime consumers via an intermediary
-   *  service are not captured. */
+  /** Workloads or Pods this ConfigMap or Secret is referenced by ("Deployment/flagd"), capped at 5.
+   *  Direct spec references only; references do not establish runtime use. */
   consumed_by?: string[];
+  /** Referencing workloads or Pods left out of consumed_by because the caller may not read them. */
+  consumed_by_withheld?: IssueWithheld;
+  running_previous_value?: IssueRunningPreviousValue;
+  updates_in_window?: number;
+  first_update_at?: string;
+}
+
+/** One finalizer removal: a JSON Patch that tests the object UID and the
+ *  finalizer at its index before removing it, previewed as dry runs. */
+export interface IssueFinalizerRemoval {
+  finalizer: string;
+  /** patch_resource tool input, with dry_run=true. */
+  patch_resource: Record<string, unknown>;
+  /** The same patch as a kubectl server-side dry run. */
+  kubectl: string;
+}
+
+export interface IssueConditionalCleanup {
+  /** Lead-in the reader must confirm, e.g. "If victoria-metrics-operator was
+   *  uninstalled on purpose (…), remove the finalizer". */
+  condition: string;
+  /** For agents: when the cleanup may be proposed. */
+  agent_guidance: string;
+  caution: string;
+  removals: IssueFinalizerRemoval[];
 }
 
 /** "No tracked non-status changes in the window" — the claim is scoped by
@@ -181,6 +222,10 @@ export interface Issue {
   reason: string;
   message?: string;
   raw_message?: string;
+  /** 'radar' when `message` is Radar's own summary rather than text from
+   *  Kubernetes or a controller. Such a message is never shown as raw output;
+   *  the server writes a `cause` that stands without it. */
+  message_source?: 'radar';
   /** Parsed domain diagnosis: plain-English cause, suggested next step, and
    *  an optional structured one-click fix.
    *  Server-emitted (omitempty); empty for issues without a parser. */
@@ -188,6 +233,9 @@ export interface Issue {
   action?: string;
   remediation_kind?: string;
   remediation_target?: string;
+  /** A cleanup that is right only when its condition holds — never part of
+   *  `action`. Shown collapsed, labeled with the condition. */
+  conditional_cleanup?: IssueConditionalCleanup;
   /** Controller-operation retry count (e.g. Argo's "(retried N times)") —
    *  distinct from restart_count (pod restarts). stuck = not expected to
    *  self-recover. */
@@ -260,6 +308,9 @@ export interface Issue {
    *  NEITHER correlation field was not checked — absence must not be read as
    *  "no changes". MCP-only, like correlated_changes. */
   no_recent_changes?: IssueNoRecentChanges;
+  /** The subject's change history in the window was larger than Radar reads,
+   *  so correlated_changes are leads, not its full history. MCP-only. */
+  correlated_changes_incomplete?: boolean;
 }
 
 /** subjectRef builds a deep-linkable ref for an issue's subject — the row's