@skyhook-io/radar-app 1.14.5 → 1.15.0

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

@@ -0,0 +1,165 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { KueueAdmission } from "./JobSetAdmission";
+const mock = vi.hoisted(() => ({ result: {} as any, calls: [] as any[] }));
+vi.mock("../../api/client", () => ({
+  ApiError: class extends Error {
+    status = 403;
+  },
+  useKueueAdmission: (...args: any[]) => {
+    mock.calls.push(args);
+    return mock.result;
+  },
+}));
+const job = {
+  apiVersion: "batch/v1",
+  kind: "Job",
+  metadata: { name: "train", namespace: "ml", uid: "current" },
+  spec: { suspend: true },
+};
+const empty = {
+  uid: "current",
+  installed: true,
+  workloads: [],
+  total: 0,
+  truncated: false,
+};
+const evidence = {
+  ...empty,
+  total: 1,
+  workloads: [
+    {
+      name: "owned-workload",
+      uid: "w",
+      apiVersion: "kueue.x-k8s.io/v1beta2",
+      projection: "unsupported",
+    },
+  ],
+};
+const hinted = {
+  ...job,
+  metadata: {
+    ...job.metadata,
+    labels: { "kueue.x-k8s.io/queue-name": "ready" },
+  },
+};
+const render = (resource: any = job) =>
+  renderToStaticMarkup(
+    <KueueAdmission resource={resource} namespace="ml" name="train" />,
+  );
+describe("Job admission host", () => {
+  beforeEach(() => {
+    mock.result = {};
+    mock.calls = [];
+  });
+  it.each([
+    { isLoading: true },
+    { data: empty },
+    { error: new Error("denied") },
+  ])("keeps plain suspended Jobs quiet: %j", (result) => {
+    mock.result = result;
+    expect(render()).toBe("");
+    expect(mock.calls[0][3]).toEqual({
+      isJob: true,
+      isRayJob: false,
+      hinted: false,
+      terminal: false,
+    });
+  });
+  it("discovers unlabeled evidence but hides it after errors", () => {
+    mock.result = { data: evidence };
+    expect(render()).toContain("owned-workload");
+    mock.result.error = new Error("cache unavailable");
+    expect(render()).toContain("cache unavailable");
+    expect(render()).not.toContain("owned-workload");
+  });
+  it("rejects reused-name evidence", () => {
+    mock.result = { data: { ...evidence, uid: "old" } };
+    expect(render(hinted)).toContain("different workload instance");
+    expect(render(hinted)).not.toContain("owned-workload");
+  });
+  it("shows missing evidence and conditional owner guidance for a hinted child", () => {
+    mock.result = { data: empty };
+    const html = render({
+      ...hinted,
+      metadata: {
+        ...hinted.metadata,
+        ownerReferences: [{ controller: true, kind: "JobSet", name: "parent" }],
+      },
+    });
+    expect(html).toContain("Admission may be tracked on the owning resource");
+    expect(html).not.toContain("Admission is tracked");
+  });
+  it("does not use failed Pod counts as terminal or arbitrary managedBy as Kueue hint", () => {
+    render({
+      ...job,
+      spec: { managedBy: "other.io/controller" },
+      status: { failed: 1 },
+    });
+    expect(mock.calls[0][3]).toEqual({
+      isJob: true,
+      isRayJob: false,
+      hinted: false,
+      terminal: false,
+    });
+  });
+  it("preserves JobSet errors", () => {
+    mock.result = { error: new Error("denied") };
+    expect(
+      render({
+        ...job,
+        apiVersion: "jobset.x-k8s.io/v1alpha2",
+        kind: "JobSet",
+      }),
+    ).toContain("denied");
+  });
+});
+
+describe("JobSet admission identity", () => {
+  it("rejects evidence and absence for a different root instance", () => {
+    const resource = {
+      ...job,
+      apiVersion: "jobset.x-k8s.io/v1alpha2",
+      kind: "JobSet",
+    };
+    mock.result = { data: evidence };
+    expect(render(resource)).toContain("owned-workload");
+    mock.result = { data: { ...evidence, uid: "old" } };
+    expect(render(resource)).toContain("different workload instance");
+    expect(render(resource)).not.toContain("owned-workload");
+    mock.result = { data: { ...empty, uid: "old", installed: false } };
+    expect(render(resource)).toContain("different workload instance");
+    mock.result.data.uid = "current";
+    expect(render(resource)).toBe("");
+  });
+});
+
+it("does not suggest parent admission for a CronJob-created Job", () => {
+  mock.result = { data: empty };
+  const html = render({
+    ...hinted,
+    metadata: {
+      ...hinted.metadata,
+      ownerReferences: [
+        { apiVersion: "batch/v1", kind: "CronJob", controller: true },
+      ],
+    },
+  });
+  expect(html).toContain("No controller-owned Kueue Workload observed");
+  expect(html).not.toContain("Admission may be tracked");
+});
+
+
+describe("RayJob admission", () => {
+  it("uses RayJob identity and controller terminal status without inventing a Kueue hint", () => {
+    mock.result = { data: empty };
+    expect(render({ ...job, apiVersion: "ray.io/v1", kind: "RayJob", spec: { managedBy: "ray.io/kuberay-operator" }, status: { jobDeploymentStatus: "Complete" } })).toBe("");
+    expect(mock.calls.at(-1)?.[3]).toEqual({ isJob: false, isRayJob: true, hinted: false, terminal: true });
+  });
+  it("keeps MultiKueue admission visible separately from remote execution", () => {
+    mock.result = { data: empty };
+    const html = render({ ...job, apiVersion: "ray.io/v1", kind: "RayJob", spec: { managedBy: "kueue.x-k8s.io/multikueue" } });
+    expect(html).toContain("No controller-owned Kueue Workload observed");
+    expect(mock.calls.at(-1)?.[3]).toEqual({ isJob: false, isRayJob: true, hinted: true, terminal: false });
+  });
+});

package/src/components/execution/JobSetAdmission.tsx

@@ -0,0 +1,26 @@
+import { KueueAdmissionSection } from '@skyhook-io/k8s-ui/components/resources/KueueAdmissionSection'
+import { ApiError, useKueueAdmission } from '../../api/client'
+
+export function KueueAdmission({ resource, namespace, name, onNavigate, presentation }: {
+  presentation?: 'card' | 'drawer'
+  resource: any
+  namespace: string
+  name: string
+  onNavigate?: (ref: { kind: string; namespace: string; name: string; group?: string }) => void
+}) {
+  const isJob = resource.apiVersion === 'batch/v1' && resource.kind === 'Job'
+  const isRayJob = resource.apiVersion === 'ray.io/v1' && resource.kind === 'RayJob'
+  const labels = resource.metadata?.labels
+  const annotations = resource.metadata?.annotations
+  const externalExecution = Boolean(resource.spec?.managedBy && resource.spec.managedBy !== (isRayJob ? 'ray.io/kuberay-operator' : isJob ? 'kubernetes.io/job-controller' : 'jobset.sigs.k8s.io/jobset-controller'))
+  const hinted = Boolean(labels?.['kueue.x-k8s.io/queue-name'] || labels?.['kueue.x-k8s.io/prebuilt-workload-name'] || annotations?.['kueue.x-k8s.io/prebuilt-workload-name'] || resource.spec?.managedBy === 'kueue.x-k8s.io/multikueue' || (!isJob && !isRayJob && externalExecution))
+  const terminal = (isRayJob && ['Complete', 'Failed', 'ValidationFailed'].includes(resource.status?.jobDeploymentStatus)) || (resource.status?.conditions ?? []).some((c: any) => ['Complete', 'Failed'].includes(c.type) && c.status === 'True')
+  const query = useKueueAdmission(namespace, name, resource.metadata?.uid, { isJob, isRayJob, hinted, terminal })
+  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 workload instance; waiting for a fresh observation.' : undefined)
+  if ((isJob || isRayJob) && !hinted && !data?.workloads.length) return null
+  const hasOwner = (resource.metadata?.ownerReferences ?? []).some((owner: any) => owner.controller === true && !(owner.apiVersion === 'batch/v1' && owner.kind === 'CronJob'))
+  return <KueueAdmissionSection presentation={presentation} data={data} loading={query.isLoading} error={error} forbidden={query.error instanceof ApiError && query.error.status === 403} hinted={hinted} externalExecution={externalExecution} hasOwner={isJob && hasOwner} onRetry={() => { void query.refetch() }} onNavigate={onNavigate} />
+}
+
+export { KueueAdmission as JobSetAdmission }

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()
+  })
+})