@skyhook-io/radar-app 1.14.5 → 1.14.6

package/src/components/execution/JobSetAdmission.test.tsx

@@ -0,0 +1,42 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { KueueAdmissionResponse } from '@skyhook-io/k8s-ui/types/scheduling'
+import { JobSetAdmission } from './JobSetAdmission'
+
+const state = vi.hoisted(() => ({ data: undefined as KueueAdmissionResponse | undefined, query: vi.fn() }))
+vi.mock('../../api/client', () => ({
+  ApiError: class extends Error {},
+  useKueueAdmission: (...args: unknown[]) => {
+    state.query(...args)
+    return { data: state.data, isLoading: false, refetch: vi.fn() }
+  },
+}))
+
+beforeEach(() => {
+  state.query.mockClear()
+  state.data = { uid: 'old-uid', installed: true, total: 1, truncated: false, workloads: [{
+    apiVersion: 'kueue.x-k8s.io/v1beta2', namespace: 'ml', name: 'old-workload', uid: 'workload-uid', generation: 1,
+    createdAt: null, deleting: false, projection: 'unsupported', linksLimited: false,
+  }] }
+})
+
+function render(uid: string) {
+  return renderToStaticMarkup(<JobSetAdmission resource={{ metadata: { uid } }} namespace="ml" name="training" />)
+}
+
+describe('JobSet admission identity', () => {
+  it('rejects old evidence after recreation under the same name', () => {
+    expect(render('old-uid')).toContain('old-workload')
+    const html = render('new-uid')
+    expect(state.query).toHaveBeenLastCalledWith('ml', 'training', 'new-uid')
+    expect(html).not.toContain('old-workload')
+    expect(html).toContain('different JobSet instance')
+  })
+
+  it('accepts absence only for the displayed root instance', () => {
+    state.data = { uid: 'old-uid', installed: false, total: 0, truncated: false, workloads: [] }
+    expect(render('new-uid')).toContain('different JobSet instance')
+    state.data.uid = 'new-uid'
+    expect(render('new-uid')).toBe('')
+  })
+})

package/src/components/execution/JobSetAdmission.tsx

@@ -0,0 +1,17 @@
+import { KueueAdmissionSection } from '@skyhook-io/k8s-ui/components/resources/KueueAdmissionSection'
+import { ApiError, useKueueAdmission } from '../../api/client'
+
+export function JobSetAdmission({ resource, namespace, name, onNavigate }: {
+  resource: any
+  namespace: string
+  name: string
+  onNavigate?: (ref: { kind: string; namespace: string; name: string; group?: string }) => void
+}) {
+  const query = useKueueAdmission(namespace, name, resource.metadata?.uid)
+  const data = query.data?.uid === resource.metadata?.uid ? query.data : undefined
+  const error = query.error?.message ?? (query.data && !data ? 'Admission evidence belongs to a different JobSet instance; waiting for a fresh observation.' : undefined)
+  const labels = resource.metadata?.labels
+  const externalExecution = Boolean(resource.spec?.managedBy && resource.spec.managedBy !== 'jobset.sigs.k8s.io/jobset-controller')
+  const hinted = Boolean(labels?.['kueue.x-k8s.io/queue-name'] || labels?.['kueue.x-k8s.io/prebuilt-workload-name'] || externalExecution)
+  return <KueueAdmissionSection data={data} loading={query.isLoading} error={error} forbidden={query.error instanceof ApiError && query.error.status === 403} hinted={hinted} externalExecution={externalExecution} onRetry={() => { void query.refetch() }} onNavigate={onNavigate} />
+}

package/src/components/execution/JobSetMemberComparison.test.tsx

@@ -0,0 +1,30 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { JobSetMemberComparison } from './JobSetMemberComparison'
+import type { JobSetUsage } from '../../api/client'
+
+const empty: JobSetUsage = { runningPods: 0, reportingPods: 0, stalePods: 0, cpu: null, memory: null, cpuRequest: 0, memoryRequest: 0 }
+function render(usage: JobSetUsage) {
+  return renderToStaticMarkup(<JobSetMemberComparison runs={[{ group: 'batch', kind: 'jobs', namespace: 'ns', name: 'leader', phase: 'Running', active: true, jobset: { replicatedJob: 'leader', jobIndex: '0' } }]} total={250} filteredTotal={1} truncated={false} loading={false} error={null} roles={['leader']} role="leader" onRoleChange={() => {}} search="" onSearchChange={() => {}} state="all" onStateChange={() => {}} selected="jobs/ns/leader" resourcesLoading={false} resourceError={null} durationFor={() => '2m'} resources={{ uid: 'root', source: 'metrics.k8s.io', total: usage, members: { leader: usage } }} />)
+}
+
+describe('JobSet resource comparison', () => {
+  it('keeps absent usage distinct from measured zero and completed Pods', () => {
+    const absent = render({ ...empty, runningPods: 2 })
+    expect(absent).toContain('0/2 running Pods reporting')
+    expect(absent).not.toContain('0m')
+    const zero = render({ ...empty, runningPods: 1, reportingPods: 1, cpu: 0, memory: 0 })
+    expect(zero).toContain('1/1 running Pods reporting')
+    expect(zero).not.toContain('Unavailable')
+    expect(render(empty)).toContain('No running Pods')
+  })
+  it('shows partial coverage, stale samples, independent counts and declared extended requests', () => {
+    const html = render({ ...empty, runningPods: 2, reportingPods: 1, stalePods: 1, cpu: 25000000, memory: 33554432, cpuRequest: 100000000, memoryRequest: 67108864, extendedRequests: { 'nvidia.com/gpu': '2' } })
+    expect(html).toContain('1/2 running Pods reporting')
+    expect(html).toContain('1 stale')
+    expect(html).toContain('250 retained')
+    expect(html).toContain('1 matching')
+    expect(html).toContain('usage not collected')
+    expect(html).toContain('outside these filters')
+  })
+})

package/src/components/execution/JobSetMemberComparison.tsx

@@ -0,0 +1,88 @@
+import { Badge, EmptyState, FetchResult } from '@skyhook-io/k8s-ui'
+import { formatCPUNanocores, formatMemoryBytes } from '@skyhook-io/k8s-ui/utils/format'
+import type { JobSetResources, JobSetUsage, WorkloadRun } from '../../api/client'
+
+interface Props {
+  runs: WorkloadRun[]
+  total: number
+  filteredTotal: number
+  truncated: boolean
+  loading: boolean
+  error: unknown
+  roles: string[]
+  role: string
+  onRoleChange: (value: string) => void
+  search: string
+  onSearchChange: (value: string) => void
+  state: 'all' | 'active' | 'failed'
+  onStateChange: (value: 'all' | 'active' | 'failed') => void
+  selected: string
+  onSelect?: (key: string) => void
+  resources?: JobSetResources
+  resourcesLoading: boolean
+  resourceError: unknown
+  durationFor: (run: WorkloadRun) => string
+}
+
+function UsageValue({ usage, resource }: { usage?: JobSetUsage; resource: 'cpu' | 'memory' }) {
+  const value = usage?.[resource]
+  if (value === undefined || value === null) return <span className="text-theme-text-tertiary">—</span>
+  const format = resource === 'cpu' ? formatCPUNanocores : formatMemoryBytes
+  const request = resource === 'cpu' ? usage!.cpuRequest : usage!.memoryRequest
+  return <><span className="tabular-nums text-theme-text-primary">{format(value)}</span><span className="block text-[10px] text-theme-text-tertiary">{request > 0 ? `${format(request)} requested` : 'No request reported'}</span></>
+}
+
+function Coverage({ usage }: { usage?: JobSetUsage }) {
+  if (!usage) return <span className="text-theme-text-tertiary">Unavailable</span>
+  return <span className="text-theme-text-secondary">{usage.runningPods === 0 ? 'No running Pods' : `${usage.reportingPods}/${usage.runningPods} running Pods reporting`}{usage.stalePods > 0 && ` · ${usage.stalePods} stale`}</span>
+}
+
+export function JobSetMemberComparison(props: Props) {
+  const { resources, runs, role, roles } = props
+  const ordered = [...runs].sort((a, b) => (a.jobset?.replicatedJob ?? '').localeCompare(b.jobset?.replicatedJob ?? ''))
+  const inputClass = 'rounded-md border border-theme-border bg-theme-elevated px-2 py-1.5 text-xs text-theme-text-primary'
+  return <section className="rounded-lg border border-theme-border bg-theme-surface" aria-label="Member Jobs">
+    <div className="space-y-3 border-b border-theme-border p-3">
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <h3 className="text-sm font-semibold text-theme-text-primary">Member Jobs <span className="font-normal text-theme-text-tertiary">{props.loading ? '· Loading Jobs…' : runs.length === props.total ? `· ${props.total} Jobs` : `· ${runs.length} shown · ${props.filteredTotal} matching · ${props.total} retained`}</span></h3>
+        <span className="text-xs text-theme-text-tertiary">Controller-owned Jobs currently in Kubernetes</span>
+      </div>
+      <div className="flex flex-wrap items-center gap-2">
+        <select aria-label="Filter member role" value={role} onChange={e => props.onRoleChange(e.target.value)} className={inputClass}>
+          <option value="">All roles</option>{[...new Set([...roles, ...runs.map(run => run.jobset?.replicatedJob).filter((name): name is string => Boolean(name)), ...(role ? [role] : [])])].map(name => <option key={name} value={name}>{name}</option>)}
+        </select>
+        <select aria-label="Filter member state" value={props.state} onChange={e => props.onStateChange(e.target.value as Props['state'])} className={inputClass}><option value="all">All states</option><option value="active">Active</option><option value="failed">Failed</option></select>
+        <input aria-label="Search all member Jobs" value={props.search} onChange={e => props.onSearchChange(e.target.value)} placeholder="Search all member Jobs" className={`${inputClass} min-w-48 flex-1`} />
+        {(role || props.state !== 'all' || props.search) && <button type="button" className="text-xs text-accent-text hover:underline" onClick={() => { props.onRoleChange(''); props.onStateChange('all'); props.onSearchChange('') }}>Clear filters</button>}
+      </div>
+      {resources && <div className="flex flex-wrap items-start gap-x-5 gap-y-2 text-xs">
+        <span className="font-medium text-theme-text-secondary">Whole JobSet<br/><span className="font-normal text-theme-text-tertiary">Current resource usage</span></span>
+        <span>CPU <UsageValue usage={resources.total} resource="cpu" /></span>
+        <span>Memory <UsageValue usage={resources.total} resource="memory" /></span>
+        <span><Coverage usage={resources.total}/>{resources.total.observedAt && <span className="block text-[10px] text-theme-text-tertiary">Oldest sample: {new Date(resources.total.observedAt).toLocaleTimeString()}</span>}</span>
+        {resources.total.extendedRequests && Object.entries(resources.total.extendedRequests).map(([name, count]) => <span key={name} className="text-theme-text-secondary">{name}: {count} requested<span className="block text-[10px] text-theme-text-tertiary">Nonterminal Pods · usage not collected</span></span>)}
+      </div>}
+      {Boolean(resources?.unavailable || props.resourceError) && <p className="text-xs text-theme-text-secondary">{resources?.unavailable || (props.resourceError instanceof Error ? props.resourceError.message : 'Resource usage unavailable.')}</p>}
+      {!resources && !props.resourceError && props.resourcesLoading && <p className="text-xs text-theme-text-tertiary">Loading resource usage…</p>}
+    </div>
+    {props.loading ? <FetchResult loading className="min-h-24" /> : props.error ? <EmptyState variant="card" tone="neutral" headline="Member Jobs unavailable" body={props.error instanceof Error ? props.error.message : 'Unable to read child Jobs.'} /> : runs.length === 0 ? <EmptyState variant="card" tone="neutral" headline={props.total ? 'No Jobs match these filters' : 'No child Jobs currently retained'} body={props.total ? 'Change the role, state, or name filter.' : 'Jobs may not exist yet, may be managed externally, or may already have been cleaned up.'} /> : <div className="max-h-72 overflow-auto">
+      <table className="w-full text-left text-xs">
+        <thead className="sticky top-0 bg-theme-surface text-theme-text-tertiary"><tr>{['Role', 'Job', 'State', 'Duration', 'CPU usage', 'Memory usage', 'Metric coverage'].map(label => <th key={label} className="whitespace-nowrap border-b border-theme-border px-3 py-2 font-medium">{label}</th>)}</tr></thead>
+        <tbody>{ordered.map(run => {
+          const key = `${run.kind}/${run.namespace}/${run.name}`
+          const usage = resources?.members[run.name]
+          return <tr key={key} className={`border-b border-theme-border-subtle last:border-0 ${props.selected === key ? 'selection' : 'hover:bg-theme-hover'}`}>
+            <td className="px-3 py-2 text-theme-text-secondary">{run.jobset?.replicatedJob ?? 'Not reported'}{run.jobset?.jobIndex !== undefined && ` #${run.jobset.jobIndex}`}</td>
+            <th scope="row" className="max-w-xs px-3 py-2 font-medium"><button type="button" aria-pressed={props.selected === key} className="block max-w-full truncate text-accent-text hover:underline" onClick={() => props.onSelect?.(key)}>{run.name}</button></th>
+            <td className="px-3 py-2"><Badge severity={run.phase === 'Failed' || run.phase === 'Error' ? 'error' : run.phase === 'Succeeded' ? 'success' : run.active ? 'info' : 'neutral'}>{run.phase}{run.deleting ? ' · deleting' : ''}</Badge></td>
+            <td className="whitespace-nowrap px-3 py-2 text-theme-text-secondary">{props.durationFor(run) || '—'}</td>
+            <td className="whitespace-nowrap px-3 py-2"><UsageValue usage={usage} resource="cpu" /></td>
+            <td className="whitespace-nowrap px-3 py-2"><UsageValue usage={usage} resource="memory" /></td>
+            <td className="px-3 py-2"><Coverage usage={usage}/>{usage?.extendedRequests && Object.entries(usage.extendedRequests).map(([name, count]) => <span key={name} className="block text-[10px] text-theme-text-tertiary">{name}: {count} requested · usage not collected</span>)}</td>
+          </tr>
+        })}</tbody>
+      </table>
+    </div>}
+    <p className="border-t border-theme-border px-3 py-2 text-[10px] text-theme-text-tertiary">Usage and requests cover reporting running Pods only; missing and stale samples are excluded. Whole-JobSet totals include members outside these filters.{props.truncated && ' Only the first 200 matching Jobs are shown. Refine the search to find another member.'}</p>
+  </section>
+}

package/src/components/execution/batch-run-actions.test.ts

@@ -5,6 +5,7 @@ import { batchRunNextStep } from './batch-run-actions'
 function run(phase: string, counts: Partial<Pick<WorkloadRun, 'podFailed' | 'podSucceeded' | 'podRunning' | 'podPending'>> = {}): WorkloadRun {
   return {
     kind: 'jobs',
+      group: 'batch',
     namespace: 'jobs',
     name: 'example',
     phase,

package/src/components/execution/batch-timeline.test.ts

@@ -7,6 +7,7 @@ describe('workloadRunTimelineEvents', () => {
     const runs: WorkloadRun[] = [
       {
         kind: 'jobs',
+      group: 'batch',
         namespace: 'dev',
         name: 'nightly-1',
         phase: 'Succeeded',
@@ -17,6 +18,7 @@ describe('workloadRunTimelineEvents', () => {
       },
       {
         kind: 'jobs',
+      group: 'batch',
         namespace: 'dev',
         name: 'nightly-2',
         phase: 'Failed',
@@ -43,6 +45,7 @@ describe('workloadRunTimelineEvents', () => {
   it('uses Workflow resource identity for Argo runs', () => {
     const events = workloadRunTimelineEvents([{
       kind: 'workflows',
+      group: 'argoproj.io',
       namespace: 'dev',
       name: 'migration-abc',
       phase: 'Error',

package/src/components/execution/execution-definition.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { executionDefinitionFingerprint, executionDefinitionSummary } from './execution-definition'
+import { executionDefinitionDiffers, executionDefinitionFingerprint, executionDefinitionSummary } from './execution-definition'
 
 describe('executionDefinitionSummary', () => {
   it('explains a Kubernetes Job pod template and effective defaults', () => {
@@ -139,6 +139,20 @@ describe('executionDefinitionSummary', () => {
     expect(executionDefinitionFingerprint(stored)).toBe(executionDefinitionFingerprint(current))
   })
 
+  it('only reports drift when both definitions are comparable', () => {
+    const captured = executionDefinitionSummary('Job', {
+      spec: { template: { spec: { containers: [{ name: 'worker', image: 'example/worker:v1' }] } } },
+    })
+    const changed = executionDefinitionSummary('Job', {
+      spec: { template: { spec: { containers: [{ name: 'worker', image: 'example/worker:v2' }] } } },
+    })
+
+    expect(executionDefinitionDiffers(null, captured)).toBe(false)
+    expect(executionDefinitionDiffers(captured, null)).toBe(false)
+    expect(executionDefinitionDiffers(captured, captured)).toBe(false)
+    expect(executionDefinitionDiffers(captured, changed)).toBe(true)
+  })
+
   it('reads a ScaledJob embedded Job target', () => {
     const summary = executionDefinitionSummary('ScaledJob', {
       spec: {

package/src/components/execution/execution-definition.ts

@@ -56,6 +56,10 @@ export function executionDefinitionFingerprint(summary: ExecutionDefinitionSumma
   return JSON.stringify(summary)
 }
 
+export function executionDefinitionDiffers(current: ExecutionDefinitionSummary | null, captured: ExecutionDefinitionSummary | null): boolean {
+  return current != null && captured != null && executionDefinitionFingerprint(current) !== executionDefinitionFingerprint(captured)
+}
+
 function kubernetesJobSummary(jobSpec: any): ExecutionDefinitionSummary {
   const podSpec = jobSpec.template?.spec ?? {}
   const containers = Array.isArray(podSpec.containers) ? podSpec.containers : []

package/src/components/execution/member-collection.render.test.tsx

@@ -0,0 +1,142 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { WorkloadRun, WorkloadRunsResponse } from '../../api/client'
+import { BatchExecutionFullscreen } from './BatchExecutionView'
+import { ScheduledWorkloadLogsViewer, workloadRunLogsKey } from '../logs/ScheduledWorkloadLogsViewer'
+
+const state = vi.hoisted(() => ({
+  response: { collection: 'members', runs: [], total: 0, truncated: false } as WorkloadRunsResponse | undefined,
+  isLoading: false,
+  error: undefined as Error | undefined,
+  useResource: vi.fn().mockReturnValue({ data: { spec: {} } }),
+}))
+
+vi.mock('../../api/client', () => ({
+  useResource: (...args: unknown[]) => state.useResource(...args),
+  useWorkloadPods: () => ({ data: { pods: [], total: 0, truncated: false } }),
+  useJobSetResources: () => ({ data: undefined, isLoading: false }),
+  useWorkloadRuns: () => ({ data: state.response, isLoading: state.isLoading, error: state.error }),
+}))
+vi.mock('../logs/WorkloadLogsViewer', () => ({
+  WorkloadLogsViewer: ({ kind, namespace, name }: { kind: string; namespace: string; name: string }) => <div data-log-target={`${kind}/${namespace}/${name}`}>Logs for {name}</div>,
+}))
+vi.mock('./JobSetAdmission', () => ({ JobSetAdmission: () => null }))
+
+const member: WorkloadRun = {
+  group: 'batch', kind: 'jobs', namespace: 'training', name: 'distributed-workers-0',
+  phase: 'Running', active: true,
+  jobset: { replicatedJob: 'workers', jobIndex: '0', replicatedJobReplicas: '2', restartAttempt: '0', jobRestartAttempt: '0' },
+}
+
+function overview(selectedRunKey?: string, apiVersion = 'jobset.x-k8s.io/v1alpha2') {
+  return renderToStaticMarkup(<BatchExecutionFullscreen kind="JobSet" apiKind="jobsets" namespace="training" name="distributed" resource={{ apiVersion, kind: 'JobSet', spec: { replicatedJobs: [{ name: 'workers', replicas: 2 }] } }} selectedRunKey={selectedRunKey} />)
+}
+function logs(selectedRunKey?: string) {
+  return renderToStaticMarkup(<ScheduledWorkloadLogsViewer kind="JobSet" namespace="training" name="distributed" selectedRunKey={selectedRunKey} />)
+}
+
+beforeEach(() => {
+  state.response = { collection: 'members', runs: [member], total: 1, truncated: false }
+  state.isLoading = false
+  state.error = undefined
+  state.useResource.mockReset()
+  state.useResource.mockReturnValue({ data: { spec: {} } })
+})
+
+describe('member collection consumers', () => {
+  it('keeps the root and declared roles visible during the first member load', () => {
+    state.response = undefined
+    state.isLoading = true
+    const html = overview()
+    expect(html).toContain('JobSet overview')
+    expect(html).toContain('Role progress')
+    expect(html).toContain('Loading Jobs')
+    expect(html).not.toContain('No child Jobs currently retained')
+    expect(html).not.toContain('Inspect')
+  })
+
+  it('keeps the root visible when member reads fail, without claiming absence', () => {
+    state.response = undefined
+    state.error = new Error('Forbidden: Jobs are not readable')
+    const html = overview()
+    expect(html).toContain('JobSet overview')
+    expect(html).toContain('Member Jobs unavailable')
+    expect(html).toContain('Forbidden: Jobs are not readable')
+    expect(html).not.toContain('No child Jobs currently retained')
+    expect(overview(undefined, 'other.example/v1')).not.toContain('JobSet overview')
+  })
+
+  it('renders nested role, zero index and selected member in Overview and Logs', () => {
+    const html = overview('jobs/training/distributed-workers-0')
+    expect(html).toContain('Member Jobs')
+    expect(html).toContain('workers #0')
+    expect(html).toContain('JobSet restart attempt')
+    expect(html).not.toContain('Run history')
+    expect(state.useResource).toHaveBeenCalledWith('jobs', 'training', member.name, 'batch', expect.objectContaining({ enabled: true }))
+    const logHTML = logs('jobs/training/distributed-workers-0')
+    expect(logHTML).toContain('workers #0')
+    expect(logHTML).toContain(`Logs for ${member.name}`)
+    expect(logHTML).toContain(`data-log-target="jobs/training/${member.name}"`)
+    expect(logHTML).not.toContain('data-log-target="jobsets/')
+  })
+
+  it('does not silently select a different member outside a truncated window', () => {
+    state.response = { collection: 'members', runs: [member], total: 201, truncated: true }
+    const missing = 'jobs/training/omitted-worker'
+    expect(overview(missing)).toContain('Selected Job is currently unavailable')
+    const html = logs(missing)
+    expect(html).toContain('Select a shown member Job')
+    expect(html).not.toContain('Logs for')
+  })
+
+  it.each([{ remaining: [] }, { remaining: [{ ...member, name: 'other-worker' }] }])('preserves an explicit member through a recreation gap with $remaining', ({ remaining }) => {
+    const selected = 'jobs/training/distributed-workers-0'
+    state.response = { collection: 'members', runs: remaining, total: remaining.length, truncated: false }
+    expect(overview(selected)).toContain('Selected Job is currently unavailable')
+    const html = logs(selected)
+    expect(html).toContain('Your selection is preserved if it reappears')
+    expect(html).not.toContain('truncated window')
+    expect(html).not.toContain('Logs for')
+    if (remaining.length === 0) expect(html).not.toContain('aria-label="Select a shown member Job"')
+    state.response = { collection: 'members', runs: [member], total: 1, truncated: false }
+    expect(logs(selected)).toContain(`Logs for ${member.name}`)
+    expect(overview(selected)).not.toContain('Selected Job is currently unavailable')
+  })
+
+  it('opens the exact selected member outside the list in Overview and Logs', () => {
+    const selected = { ...member, name: 'off-window' }
+    state.response = { collection: 'members', runs: [member], selected, total: 250, filteredTotal: 250, truncated: true }
+    const key = 'jobs/training/off-window'
+    expect(overview(key)).toContain('Selected Job is outside the current filter or shown window')
+    expect(logs(key)).toContain('Logs for off-window')
+    expect(logs(key)).not.toContain('Selected Job is currently unavailable')
+  })
+
+  it('waits for declared roles before enabling a role log scope', () => {
+    state.useResource.mockReturnValue({ data: undefined })
+    expect(logs()).toContain('<option value="role" disabled="">Role</option>')
+    state.useResource.mockReturnValue({ data: { spec: { replicatedJobs: [{ name: 'prepare' }, { name: 'workers' }] } } })
+    expect(logs()).toContain('<option value="role">Role</option>')
+  })
+
+  it('uses collection semantics even when there are no members', () => {
+    state.response = { collection: 'members', runs: [], total: 0, truncated: false }
+    expect(overview()).toContain('Member Jobs')
+    expect(overview()).toContain('No child Jobs currently retained')
+    expect(logs()).toContain('No child Jobs found')
+  })
+
+  it('reads response semantics instead of guessing membership from the parent kind', () => {
+    state.response = { collection: 'runs', runs: [{ ...member, jobset: undefined }], total: 1, truncated: false }
+    expect(overview()).toContain('Run history')
+    expect(overview()).not.toContain('Member Jobs')
+    expect(logs()).not.toContain('workers #0')
+  })
+
+  it('restarts logs for either native retry scope at the same Job address', () => {
+    expect(workloadRunLogsKey({ ...member })).toBe(workloadRunLogsKey(member))
+    expect(workloadRunLogsKey({ ...member, jobset: { ...member.jobset, restartAttempt: '1' } })).not.toBe(workloadRunLogsKey(member))
+    expect(workloadRunLogsKey({ ...member, jobset: { ...member.jobset, jobRestartAttempt: '1' } })).not.toBe(workloadRunLogsKey(member))
+    expect(workloadRunLogsKey({ ...member, jobset: {} })).not.toBe(workloadRunLogsKey(member))
+  })
+})

package/src/components/gitops/GitOpsView.tsx

@@ -19,6 +19,7 @@ import {
   formatGitOpsSourceUrl,
   getGitOpsResourceStatus,
   getGitOpsTool,
+  isDestinationRef,
   isArgoOperationInProgress,
   isArgoSuspendedByRadar,
   gitOpsInsightChangeKey,
@@ -40,11 +41,15 @@ import {
   type GitOpsRow,
   type GitOpsRowAction,
   type GitOpsTreeFilters,
+  type GitOpsTreeNode,
   type GitOpsTreeRef,
   type GitOpsTreePreset,
   type SelectedResource,
 } from '@skyhook-io/k8s-ui'
 import { useToast } from '../ui/Toast'
+import { useContextSwitchFlow } from '../useContextSwitchFlow'
+import { useDestinationCluster } from './useDestinationCluster'
+import { destinationToast } from './destination-toast'
 
 import {
   fetchJSON,
@@ -352,7 +357,7 @@ function GitOpsTableView({ namespaces, onClearNamespaces }: { namespaces: string
 function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOpsViewProps) {
   const location = useLocation()
   const navigate = useNavigate()
-  const { showError, showSuccess } = useToast()
+  const { showError, showSuccess, showToast } = useToast()
   const parts = location.pathname.split('/').filter(Boolean)
   const kind = parts[2] || 'applications'
   const namespace = parts[3] === '_' ? '' : decodePathPart(parts[3] || '')
@@ -380,6 +385,7 @@ function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOps
   const resourceQ = useResource<any>(kind, namespace, name, group)
   const treeQ = useGitOpsTree(kind, namespace, name, group, namespaces)
   const insightsQ = useGitOpsInsights(kind, namespace, name, group, namespaces)
+  const switchFlow = useContextSwitchFlow()
   const status = resourceQ.data ? getGitOpsResourceStatus(kind, resourceQ.data) : null
   const tool = getGitOpsTool(kind, group)
   // Argo "auto-sync ON" is determined by spec.syncPolicy.automated being set,
@@ -463,8 +469,32 @@ function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOps
     roles: graphRoles,
   }), [graphHealth, graphKinds, graphNamespaces, graphRoles, graphSync])
   const graphFacets = useMemo(() => buildTreeFacets(tree), [tree])
+  // The tree and insights load separately; either one seeing a remote
+  // destination is enough to keep its resources from opening here.
+  const remoteDestination = !!(tree?.remoteDestination || insightsQ.data?.summary?.remoteDestination)
+  const destination = useDestinationCluster(remoteDestination, kind, namespace, name)
 
-  function openResourceFromTree(ref: GitOpsTreeRef | GitOpsInsightRef) {
+  function openResourceFromTree(ref: GitOpsTreeRef | GitOpsInsightRef, node?: GitOpsTreeNode) {
+    // Locality comes from the node, not the name: a remote app can deploy a
+    // same-named copy of itself to its destination.
+    if (node?.role !== 'root' && isDestinationRef(tree, remoteDestination, ref)) {
+      const toast = destinationToast(`${ref.kind} ${ref.namespace ? `${ref.namespace}/` : ''}${ref.name}`, destination)
+      const target = destination.context
+      showToast(toast.message, {
+        type: 'info',
+        detail: toast.detail,
+        action: toast.actionLabel && target ? {
+          label: toast.actionLabel,
+          onClick: () => switchFlow.requestSwitch(target, {
+            kind: kindToPluralWithGroup(ref.kind, ref.group ?? ''),
+            namespace: ref.namespace || '',
+            name: ref.name,
+            group: ref.group,
+          }),
+        } : undefined,
+      })
+      return
+    }
     if (isGitOpsDetailRef(ref) && isValidKubernetesName(ref.name)) {
       const detailKind = kindToPluralWithGroup(ref.kind, ref.group ?? '')
       // The tree's root node is this page's own subject — clicking it must not
@@ -822,6 +852,7 @@ function GitOpsDetailView({ namespaces, onOpenResource, onOpenSettings }: GitOps
       }}
     >
       {/* Modals — portaled to body, only render the ones for the current tool. */}
+      {switchFlow.confirmDialog}
       {isArgoApp && (
         <>
           <SyncOptionsDialog

package/src/components/gitops/destination-toast.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'vitest'
+import { destinationToast } from './destination-toast'
+
+const ctx = {
+  name: 'arn:aws:eks:eu-central-1:420859418125:cluster/eks-prod-cluster',
+  cluster: 'arn:aws:eks:eu-central-1:420859418125:cluster/eks-prod-cluster',
+  user: 'u',
+  namespace: '',
+  isCurrent: false,
+}
+
+describe('destinationToast', () => {
+  test('offers to open it in the matching context', () => {
+    const t = destinationToast('ConfigMap ingress-nginx/controller', { context: ctx, server: 'https://65b5.gr7.eu-central-1.eks.amazonaws.com', canSwitch: true })
+    expect(t.message).toBe('ConfigMap ingress-nginx/controller is on eks-prod-cluster')
+    expect(t.actionLabel).toBe('Open in eks-prod-cluster')
+  })
+  test('names the cluster without an action when switching is off', () => {
+    const t = destinationToast('ConfigMap a/b', { context: ctx, server: 'https://65b5.gr7.eu-central-1.eks.amazonaws.com', canSwitch: false })
+    expect(t.message).toContain('eks-prod-cluster')
+    expect(t.actionLabel).toBeUndefined()
+  })
+  test('says which server is missing from the kubeconfig', () => {
+    const t = destinationToast('ConfigMap a/b', { server: 'https://34.73.119.131', canSwitch: true })
+    expect(t.detail).toContain('34.73.119.131')
+    expect(t.actionLabel).toBeUndefined()
+  })
+  test('unknown destination', () => {
+    const t = destinationToast('ConfigMap a/b', { canSwitch: true })
+    expect(t.message).toBe('ConfigMap a/b is on another cluster')
+    expect(t.actionLabel).toBeUndefined()
+  })
+})

package/src/components/gitops/destination-toast.ts

@@ -0,0 +1,46 @@
+import type { DestinationCluster } from './useDestinationCluster'
+import { parseContextForSwitcher } from '../../utils/context-name'
+
+export interface DestinationToast {
+  message: string
+  detail: string
+  // Set when the resource can be opened by switching to a kubeconfig context.
+  actionLabel?: string
+}
+
+// What to tell someone who clicked a resource that lives on a remote GitOps
+// object's destination cluster, and how they can open it.
+export function destinationToast(resource: string, dest: DestinationCluster): DestinationToast {
+  if (dest.context) {
+    const cluster = parseContextForSwitcher(dest.context).clusterName
+    if (!dest.canSwitch) {
+      return {
+        message: `${resource} is on ${cluster}`,
+        detail: 'Switching clusters is turned off in this Radar.',
+      }
+    }
+    return {
+      message: `${resource} is on ${cluster}`,
+      detail: 'Opening it switches Radar to that cluster.',
+      actionLabel: `Open in ${cluster}`,
+    }
+  }
+  if (dest.server) {
+    return {
+      message: `${resource} is on another cluster`,
+      detail: `No kubeconfig context points at ${hostOf(dest.server)}. Add one to open it from Radar.`,
+    }
+  }
+  return {
+    message: `${resource} is on another cluster`,
+    detail: "Radar couldn't tell which cluster, so it can't open it from here.",
+  }
+}
+
+function hostOf(server: string): string {
+  try {
+    return new URL(server).host
+  } catch {
+    return server
+  }
+}

package/src/components/gitops/useDestinationCluster.ts

@@ -0,0 +1,30 @@
+import { useCapabilities, useContexts, useGitOpsDestination } from '../../api/client'
+import type { ContextInfo } from '../../types'
+
+export interface DestinationCluster {
+  // The destination's API server host, when Radar can tell.
+  server?: string
+  // A kubeconfig context for that cluster other than the current one.
+  context?: ContextInfo
+  // Whether this Radar may switch contexts at all.
+  canSwitch: boolean
+}
+
+// Resolves where a remote GitOps object deploys and which kubeconfig context
+// reaches it. The server does the matching; this only asks for remote objects.
+export function useDestinationCluster(
+  remote: boolean | undefined,
+  kind: string,
+  namespace: string,
+  name: string,
+): DestinationCluster {
+  const destination = useGitOpsDestination(kind, namespace, name, !!remote)
+  const contexts = useContexts()
+  const capabilities = useCapabilities()
+  const contextName = destination.data?.contexts[0]
+  return {
+    server: destination.data?.server || undefined,
+    context: contextName ? contexts.data?.find((c) => c.name === contextName) : undefined,
+    canSwitch: capabilities.data?.configManagement !== 'operator',
+  }
+}