@skyhook-io/radar-app 1.14.5 → 1.15.0

package/src/components/whats-new/WhatsNewDialog.test.tsx

@@ -0,0 +1,229 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { focusManager, QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { MemoryRouter } from 'react-router-dom'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Megaphone } from 'lucide-react'
+import type { WhatsNewState } from '../../api/client'
+import { openWhatsNew, useWhatsNewStatus, WhatsNew } from './WhatsNew'
+import { RELEASE_NOTES } from './releaseNotes'
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+
+let root: Root
+let client: QueryClient
+let serverState: WhatsNewState
+const seenPosts: string[] = []
+let failSeenPosts = 0
+let pendingRead: ((state: WhatsNewState) => void) | null = null
+let holdNextRead = false
+const status = { current: { available: false, unread: false } }
+
+function memoryStorage(): Storage {
+  const items = new Map<string, string>()
+  return {
+    get length() { return items.size },
+    key: (i: number) => Array.from(items.keys())[i] ?? null,
+    getItem: (k: string) => items.get(k) ?? null,
+    setItem: (k: string, v: string) => { items.set(k, String(v)) },
+    removeItem: (k: string) => { items.delete(k) },
+    clear: () => items.clear(),
+  }
+}
+
+function StatusProbe() {
+  status.current = useWhatsNewStatus()
+  return null
+}
+
+beforeEach(() => {
+  RELEASE_NOTES.push({
+    version: 'v1.15.0',
+    releaseUrl: 'https://github.com/skyhook-io/radar/releases',
+    highlights: [{ id: 'x', icon: Megaphone, title: 'Capacity views', description: 'd' }],
+    improvements: [],
+  })
+  seenPosts.length = 0
+  failSeenPosts = 0
+  pendingRead = null
+  holdNextRead = false
+  vi.stubGlobal('localStorage', memoryStorage())
+  // Radar's own defaults: focus refetch is off unless a query opts in.
+  client = new QueryClient({ defaultOptions: { queries: { retry: false, refetchOnWindowFocus: false } } })
+  const element = document.createElement('div')
+  document.body.appendChild(element)
+  root = createRoot(element)
+  vi.stubGlobal('fetch', vi.fn(async (input: string, init?: RequestInit) => {
+    const path = new URL(input, 'http://localhost').pathname
+    if (path === '/api/capabilities') return Response.json({ deployment: { mode: serverState.storage === 'server' ? 'local' : 'in-cluster' } })
+    if (path === '/api/whats-new') {
+      const snapshot = { ...serverState }
+      if (holdNextRead) {
+        holdNextRead = false
+        return new Promise<Response>(resolve => { pendingRead = s => resolve(Response.json(s)) })
+      }
+      return Response.json(snapshot)
+    }
+    if (path === '/api/whats-new/seen' && init?.method === 'POST') {
+      seenPosts.push(JSON.parse(String(init.body)).version)
+      if (failSeenPosts > 0) {
+        failSeenPosts--
+        return Response.json({ error: 'failed to record the seen version' }, { status: 500 })
+      }
+      serverState = { ...serverState, seenVersion: seenPosts[seenPosts.length - 1] }
+      return new Response(null, { status: 204 })
+    }
+    throw new Error(`Unexpected request: ${input}`)
+  }))
+})
+
+afterEach(async () => {
+  await act(async () => root.unmount())
+  RELEASE_NOTES.length = 0
+  client.clear()
+  document.body.replaceChildren()
+  vi.unstubAllGlobals()
+})
+
+async function render(path: string) {
+  await act(async () => {
+    root.render(
+      <QueryClientProvider client={client}>
+        <MemoryRouter initialEntries={[path]}>
+          <WhatsNew onNavigate={() => {}} />
+          <StatusProbe />
+        </MemoryRouter>
+      </QueryClientProvider>,
+    )
+  })
+  await vi.waitFor(async () => {
+    await act(async () => { await new Promise(resolve => setTimeout(resolve, 0)) })
+    expect(status.current.available).toBe(true)
+  })
+}
+
+const dialog = () => document.querySelector('[role="dialog"][aria-modal="true"]')
+
+async function clickGotIt() {
+  const gotIt = Array.from(document.querySelectorAll('button')).find(b => b.textContent === 'Got it')!
+  await act(async () => { gotIt.click() })
+  await act(async () => { await new Promise(resolve => setTimeout(resolve, 0)) })
+}
+
+describe('WhatsNew', () => {
+  it('auto-opens on Home after an upgrade and records the running version on close', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.14.1', priorInstall: true }
+    await render('/')
+    expect(dialog()?.textContent).toContain('v1.14.1')
+    expect(status.current.unread).toBe(true)
+    await clickGotIt()
+    expect(seenPosts).toEqual(['v1.15.2'])
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('stays closed on a deep link, leaving the notes unread until opened on demand', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.14.1', priorInstall: true }
+    await render('/resources/pods')
+    expect(dialog()).toBeNull()
+    expect(status.current.unread).toBe(true)
+    expect(seenPosts).toEqual([])
+    await act(async () => { openWhatsNew() })
+    expect(dialog()).not.toBeNull()
+    await clickGotIt()
+    expect(seenPosts).toEqual(['v1.15.2'])
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('records a fresh install without opening', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', priorInstall: false }
+    await render('/')
+    expect(dialog()).toBeNull()
+    expect(seenPosts).toEqual(['v1.15.2'])
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('keeps the in-cluster record in the browser, never on the server', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'browser' }
+    localStorage.setItem('radar-whats-new-seen', 'v1.14.1')
+    await render('/')
+    expect(dialog()).not.toBeNull()
+    await clickGotIt()
+    expect(localStorage.getItem('radar-whats-new-seen')).toBe('v1.15.2')
+    expect(seenPosts).toEqual([])
+  })
+
+  it('records nothing when previewing another release', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.15.2', priorInstall: true }
+    RELEASE_NOTES.push({ ...RELEASE_NOTES[0], version: 'v1.14.0' })
+    serverState.seenVersion = 'v1.14.1'
+    await render('/resources/pods?whats-new=v1.14.0')
+    expect(dialog()?.textContent).toContain("What's new in Radar v1.14")
+    await clickGotIt()
+    expect(seenPosts).toEqual([])
+    expect(status.current.unread).toBe(true)
+  })
+
+  it('keeps the notes unread when recording fails, and retries on the next close', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.14.1', priorInstall: true }
+    failSeenPosts = 1
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await render('/')
+    await clickGotIt()
+    expect(seenPosts).toEqual(['v1.15.2'])
+    expect(status.current.unread).toBe(true)
+    await act(async () => { openWhatsNew() })
+    await clickGotIt()
+    expect(seenPosts).toEqual(['v1.15.2', 'v1.15.2'])
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('clears the dot when another tab acknowledges the notes', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'browser' }
+    localStorage.setItem('radar-whats-new-seen', 'v1.14.1')
+    await render('/resources/pods')
+    expect(status.current.unread).toBe(true)
+    localStorage.setItem('radar-whats-new-seen', 'v1.15.2')
+    await act(async () => { window.dispatchEvent(new Event('storage')) })
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('picks up another tab\'s acknowledgment when this window regains focus', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.14.1', priorInstall: true }
+    await render('/resources/pods')
+    expect(status.current.unread).toBe(true)
+    serverState = { ...serverState, seenVersion: 'v1.15.2' }
+    await act(async () => { focusManager.setFocused(false); focusManager.setFocused(true) })
+    await vi.waitFor(() => expect(status.current.unread).toBe(false))
+    focusManager.setFocused(undefined)
+  })
+
+  it('does not let a read that started before the acknowledgment undo it', async () => {
+    serverState = { currentVersion: 'v1.15.2', storage: 'server', seenVersion: 'v1.14.1', priorInstall: true }
+    await render('/')
+    const staleSnapshot = { ...serverState }
+    holdNextRead = true
+    await act(async () => { void client.refetchQueries({ queryKey: ['whats-new'] }) })
+    await vi.waitFor(() => expect(pendingRead).not.toBeNull())
+    await clickGotIt()
+    await vi.waitFor(() => expect(status.current.unread).toBe(false))
+    await act(async () => { pendingRead!(staleSnapshot) })
+    await act(async () => { await new Promise(resolve => setTimeout(resolve, 10)) })
+    expect(status.current.unread).toBe(false)
+  })
+
+  it('never records a development build', async () => {
+    serverState = { currentVersion: 'dev', storage: 'server', priorInstall: false }
+    RELEASE_NOTES.push({ ...RELEASE_NOTES[0], version: 'v0.0.0' })
+    await act(async () => {
+      root.render(
+        <QueryClientProvider client={client}>
+          <MemoryRouter initialEntries={['/']}><WhatsNew onNavigate={() => {}} /><StatusProbe /></MemoryRouter>
+        </QueryClientProvider>,
+      )
+    })
+    await act(async () => { await new Promise(resolve => setTimeout(resolve, 20)) })
+    expect(dialog()).toBeNull()
+    expect(seenPosts).toEqual([])
+  })
+})

package/src/components/whats-new/check-whats-new.test.ts

@@ -0,0 +1,65 @@
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+// scripts/check-whats-new.sh gates every minor release on having notes; these
+// pin what counts as an entry, against catalogs written to a temp dir.
+const script = join(__dirname, '..', '..', '..', '..', 'scripts', 'check-whats-new.sh')
+
+function check(version: string, catalog: string) {
+  const file = join(mkdtempSync(join(tmpdir(), 'whats-new-')), 'releaseNotes.ts')
+  writeFileSync(file, catalog)
+  return spawnSync('bash', [script, version], { env: { ...process.env, WHATS_NEW_CATALOG: file }, encoding: 'utf8' }).status
+}
+
+const empty = `export const RELEASE_NOTES: ReleaseNotes[] = []\n`
+const withEntry = (entry: string, before = '') => `${before}export const RELEASE_NOTES: ReleaseNotes[] = [\n${entry}\n]\n\nexport function after() {}\n`
+
+describe('check-whats-new.sh', () => {
+  it('lets patches and prereleases through without notes', () => {
+    expect(check('v1.15.1', empty)).toBe(0)
+    expect(check('v1.15.0-rc.1', empty)).toBe(0)
+  })
+
+  it('refuses a minor or major release without notes, including one with build metadata', () => {
+    expect(check('v1.15.0', empty)).toBe(1)
+    expect(check('v2.0.0', empty)).toBe(1)
+    expect(check('v1.15.0+build.1', empty)).toBe(1)
+  })
+
+  it('refuses a version that is not vX.Y.Z', () => {
+    expect(check('v1.15', empty)).toBe(1)
+    expect(check('latest', empty)).toBe(1)
+  })
+
+  it('accepts a real entry, wherever version sits in it', () => {
+    const entry = `  {\n    releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.15.0', version: 'v1.15.0',\n    highlights: [],\n  },`
+    expect(check('v1.15.0', withEntry(entry))).toBe(0)
+    expect(check('1.15.0+build.1', withEntry(entry))).toBe(0)
+  })
+
+  it('does not count comments, objects outside the catalog, or look-alike properties', () => {
+    const decoys = `// { version: 'v1.16.0' },\n/* { version: 'v1.17.0' } */\nconst draft = { version: 'v1.18.0' }\n`
+    const catalog = withEntry(`  // { version: 'v1.20.0' },\n  { notversion: 'v1.19.0' },`, decoys)
+    for (const v of ['v1.16.0', 'v1.17.0', 'v1.18.0', 'v1.19.0', 'v1.20.0']) expect(check(v, catalog), v).toBe(1)
+  })
+
+  it('ignores an object after an empty catalog, even with a semicolon', () => {
+    expect(check('v1.15.0', `export const RELEASE_NOTES: ReleaseNotes[] = [];\nconst draft = { version: 'v1.15.0' };\n`)).toBe(1)
+  })
+
+  it('does not count the words "version:" inside another entry\'s text', () => {
+    const entry = `  {\n    version: 'v1.14.0',\n    improvements: ["Set version: 'v1.15.0' in your configuration"],\n  },`
+    expect(check('v1.15.0', withEntry(entry))).toBe(1)
+  })
+
+  it('accepts a value on the line after its key, quoted keys, and space before the colon', () => {
+    expect(check('v1.15.0', withEntry(`  {\n    version:\n      'v1.15.0',\n  },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { version: "v1.15.0" },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { "version": "v1.15.0" },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  { version : 'v1.15.0' },`))).toBe(0)
+    expect(check('v1.15.0', withEntry(`  {\n    "version" :\n      "v1.15.0",\n  },`))).toBe(0)
+  })
+})

package/src/components/whats-new/releaseNotes.ts

@@ -0,0 +1,121 @@
+import type { LucideIcon } from 'lucide-react'
+import { Bot, GitCompareArrows, Layers, Network, Scale } from 'lucide-react'
+import { compareVersions } from '../../utils/version'
+
+export interface ReleaseHighlight {
+  id: string
+  icon: LucideIcon
+  title: string
+  description: string
+  /** In-app route the highlight's call to action opens. */
+  path?: string
+  cta?: string
+  /** Icon tile color, so the cards read apart at a glance. The lead card always uses the accent. */
+  tone?: HighlightTone
+}
+
+export type HighlightTone = 'violet' | 'teal' | 'emerald' | 'indigo'
+
+export interface ReleaseNotes {
+  version: string
+  /** The first highlight leads the dialog at full width. */
+  highlights: ReleaseHighlight[]
+  improvements: string[]
+  releaseUrl: string
+}
+
+// One entry per release that has something to announce. A version without its
+// own entry shows the newest entry at or below it, so a patch upgrade (or one
+// that skips the release with notes) still gets them. Every minor and major
+// release must have its own entry: scripts/check-whats-new.sh refuses to
+// release one without it.
+export const RELEASE_NOTES: ReleaseNotes[] = [
+  {
+    version: 'v1.15.0',
+    releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.15.0',
+    highlights: [
+      {
+        id: 'ai-investigations',
+        icon: Bot,
+        title: 'AI investigations that show their work',
+        // No link: the investigations workspace redirects home when this run
+        // mode can't host local agents.
+        description: 'A clear verdict and the story of what broke, with the charts, logs and config behind it placed where the agent cites them. Now also runs on OpenCode, including AWS Bedrock.',
+      },
+      {
+        id: 'gitops-manifest-diff',
+        icon: GitCompareArrows,
+        title: 'Full manifest diffs for Argo CD resources',
+        description: 'Compare the Git-rendered and live manifest of a drifted Argo CD resource, side by side or unified.',
+        tone: 'violet',
+        path: '/gitops',
+        cta: 'Open GitOps',
+      },
+      {
+        id: 'rightsizing-risks-first',
+        icon: Scale,
+        title: 'Rightsizing and cost data in MCP',
+        description: 'Agents get new optimized tools. Risks (OOM, limit conflicts and throttling) lead before cost-saving, in the UI as well.',
+        tone: 'emerald',
+        path: '/cost/rightsizing',
+        cta: 'Open Rightsizing',
+      },
+      {
+        id: 'batch-ai-workloads',
+        icon: Layers,
+        title: 'Deeper batch + AI/ML workloads support',
+        description: 'Dedicated pages for Kueue, JobSet and Ray resources, and Job and JobSet details now show why a queued job has no Pods.',
+        tone: 'teal',
+      },
+      {
+        id: 'rollout-traffic-topology',
+        icon: Network,
+        title: 'Canary and blue-green in Topology',
+        description: 'See canary and stable Pods, which Services route to each side, and the canary traffic weight.',
+        tone: 'indigo',
+        path: '/topology',
+        cta: 'Open Topology',
+      },
+    ],
+    improvements: [
+      // The grid fills row by row: pair lines of similar length.
+      'Resource tables remember your sort for each kind',
+      'Install Helm charts from OCI registries',
+      'Checks flag expired and expiring TLS certificates',
+      'Radar Desktop keeps your preferences across restarts',
+      'Issues show where a failing Pod differs from its template',
+      'PVC details say why usage data is unavailable',
+      'Issues catch Strimzi connector and admission webhook failures',
+      'Bind the web UI to a specific IP with --listen-address',
+    ],
+  },
+]
+
+export function releaseNotesFor(
+  version: string | undefined,
+  catalog: ReleaseNotes[] = RELEASE_NOTES,
+): ReleaseNotes | undefined {
+  if (!version) return undefined
+  const normalized = version.startsWith('v') ? version : `v${version}`
+  return catalog.find(notes => notes.version === normalized)
+}
+
+/** The release line a catalog entry covers, e.g. v1.15 for v1.15.0: its patches show the same notes. */
+export function releaseLine(version: string): string {
+  return version.replace(/^(v\d+\.\d+)\.\d+$/, '$1')
+}
+
+/** The newest notes for a release at or below `version` — what that version's user has access to. */
+export function latestReleaseNotesFor(
+  version: string | undefined,
+  catalog: ReleaseNotes[] = RELEASE_NOTES,
+): ReleaseNotes | undefined {
+  if (!version) return undefined
+  let latest: ReleaseNotes | undefined
+  for (const notes of catalog) {
+    const atOrBelow = compareVersions(notes.version, version)
+    if (atOrBelow === null || atOrBelow > 0) continue
+    if (!latest || (compareVersions(notes.version, latest.version) ?? 0) > 0) latest = notes
+  }
+  return latest
+}

package/src/components/workload/WorkloadView.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import { gitOpsOwnerFromRelationships } from '@skyhook-io/k8s-ui'
 import type { Relationships } from '../../types'
-import { findInheritedGitOpsLookupRef } from './WorkloadView'
+import { findInheritedGitOpsLookupRef, supportsBatchExecution } from './WorkloadView'
 
 describe('findInheritedGitOpsLookupRef', () => {
   it('follows a referenced ReplicaSet to its parent workload for inherited ownership', () => {
@@ -58,3 +58,19 @@ describe('findInheritedGitOpsLookupRef', () => {
     ).toBeNull()
   })
 })
+
+describe('supportsBatchExecution', () => {
+  it('enables only the supported JobSet API identity', () => {
+    expect(supportsBatchExecution('JobSet', 'jobsets', 'jobset.x-k8s.io', 'jobset.x-k8s.io/v1alpha2')).toBe(true)
+    expect(supportsBatchExecution('JobSet', 'jobsets', 'jobset.x-k8s.io')).toBe(false)
+    expect(supportsBatchExecution('JobSet', 'jobsets', 'example.io', 'example.io/v1alpha2')).toBe(false)
+    expect(supportsBatchExecution('JobSet', 'jobsets', 'example.io', 'jobset.x-k8s.io/v1alpha2')).toBe(false)
+    expect(supportsBatchExecution('JobSet', 'jobsets', 'jobset.x-k8s.io', 'jobset.x-k8s.io/v1beta1')).toBe(false)
+  })
+
+  it('preserves the core Job collision guard and existing scheduled kinds', () => {
+    expect(supportsBatchExecution('Job', 'jobs', 'batch')).toBe(true)
+    expect(supportsBatchExecution('Job', 'jobs', 'example.io')).toBe(false)
+    expect(supportsBatchExecution('CronJob', 'cronjobs', 'batch')).toBe(true)
+  })
+})

package/src/components/workload/WorkloadView.tsx

@@ -1,3 +1,8 @@
+import { RayJobRenderer } from '../resources/renderers/RayJobRenderer'
+import { JobRenderer, JobSetRenderer } from '../resources/renderers/JobAdmissionRenderers'
+import { RayClusterRenderer } from '../resources/renderers/RayClusterRenderer'
+import { RayServiceRenderer } from '../resources/renderers/RayServiceRenderer'
+import { KueueWorkloadRenderer } from '../resources/renderers/KueueWorkloadRenderer'
 import { useMemo, useEffect, useCallback, useRef, useState } from 'react'
 import { useQueries, useQueryClient } from '@tanstack/react-query'
 import { useNavigate, useLocation, useSearchParams } from 'react-router-dom'
@@ -29,6 +34,7 @@ import {
   type WorkloadImageTarget,
 } from '@skyhook-io/k8s-ui'
 import type { ServicePortRenderProps } from '@skyhook-io/k8s-ui/components/resources/renderers/ServiceRenderer'
+import { isJobSetV1Alpha2 } from '@skyhook-io/k8s-ui/components/resources/resource-utils-jobset-lws'
 import type { SelectedResource, ResourceRef, Relationships, ResourceWithRelationships } from '../../types'
 import {
   kindToPlural,
@@ -121,6 +127,7 @@ import { ServiceAccountRenderer } from '../resources/renderers/ServiceAccountRen
 import { RoleRenderer } from '../resources/renderers/RoleRenderer'
 import { RoleBindingRenderer } from '../resources/renderers/RoleBindingRenderer'
 import { NamespaceRenderer } from '../resources/renderers/NamespaceRenderer'
+import { CAPIClusterRenderer } from '../resources/renderers/CAPIClusterRenderer'
 import { HPARenderer } from '../resources/renderers/HPARenderer'
 import { PVCRenderer } from '../resources/renderers/PVCRenderer'
 import { RolloutRenderer } from '../resources/renderers/RolloutRenderer'
@@ -152,10 +159,27 @@ const BATCH_EXECUTION_KINDS = new Set([
   'WorkflowTemplate',
   'ClusterWorkflowTemplate',
   'ScaledJob',
+  'JobSet',
 ])
 
+export function supportsBatchExecution(kind: string, apiKind: string, group?: string, apiVersion?: string): boolean {
+  if (!BATCH_EXECUTION_KINDS.has(kind)) return false
+  if (kind === 'Job') return isCoreBatchJob(apiKind, group)
+  if (kind === 'JobSet') {
+    return group === 'jobset.x-k8s.io' && isJobSetV1Alpha2({ kind, apiVersion })
+  }
+  return true
+}
+
 // Stable reference — web renderer wrappers inject platform hooks internally
 const rendererOverrides: RendererOverrides = {
+  RayJobRenderer,
+  JobRenderer,
+  JobSetRenderer,
+  RayServiceRenderer,
+  RayClusterRenderer,
+  KueueWorkloadRenderer,
+  CAPIClusterRenderer,
   PodRenderer,
   KarpenterNodePoolRenderer,
   NodeRenderer,
@@ -548,18 +572,6 @@ export function WorkloadView({
     [searchParams, setSearchParams],
   )
 
-  const batchKind = pluralToKind(apiKind)
-  const batchExecution = BATCH_EXECUTION_KINDS.has(batchKind) &&
-    (batchKind !== 'Job' || isCoreBatchJob(apiKind, rest.group))
-  const batchRunsQuery = useWorkloadRuns(apiKind, namespace, name, expanded && batchExecution, {
-    refetchActive: true,
-    clusterScoped: batchKind === 'ClusterWorkflowTemplate',
-  })
-  const relatedTimelineEvents = useMemo(
-    () => workloadRunTimelineEvents(batchRunsQuery.data?.runs ?? []),
-    [batchRunsQuery.data?.runs],
-  )
-
   // Fetch resource with relationships
   const {
     data: resourceResponse,
@@ -579,6 +591,16 @@ export function WorkloadView({
   // of itself. Fall back to the group derived from the fetched resource, then
   // to undefined (which the gate treats as "group unknown → allow").
   const effectiveGroup = rest.group || resourceGroup || undefined
+  const batchKind = pluralToKind(apiKind)
+  const batchExecution = supportsBatchExecution(batchKind, apiKind, effectiveGroup, resource?.apiVersion)
+  const batchRunsQuery = useWorkloadRuns(apiKind, namespace, name, expanded && batchExecution, {
+    refetchActive: true,
+    clusterScoped: batchKind === 'ClusterWorkflowTemplate',
+  })
+  const relatedTimelineEvents = useMemo(
+    () => batchKind === 'JobSet' ? [] : workloadRunTimelineEvents(batchRunsQuery.data?.runs ?? []),
+    [batchKind, batchRunsQuery.data?.runs],
+  )
   // Reachability for a workload IS the reachability of the Services in front of
   // it - a Deployment has no address of its own. Empty for a workload nothing
   // selects, which correctly leaves the tab hidden: there is no path to trace.
@@ -590,14 +612,20 @@ export function WorkloadView({
   const refetchResourceAndRuns = useCallback(async () => {
     await Promise.all([
       refetchResource(),
+      ...(apiKind === 'rayjobs' && effectiveGroup === 'ray.io' ? [
+        queryClient.refetchQueries({ queryKey: ['resource', 'jobs', namespace, name, 'batch'], type: 'active' }),
+        ...(resource?.spec?.clusterSelector?.['ray.io/cluster'] ? [queryClient.refetchQueries({ queryKey: ['resource', 'rayclusters', namespace, resource.spec.clusterSelector['ray.io/cluster'], 'ray.io'], type: 'active' })] : []),
+      ] : []),
+      queryClient.refetchQueries({ queryKey: ['kueue-admission', effectiveGroup, apiKind, namespace, name], type: 'active' }),
       queryClient.refetchQueries({
         queryKey: ['workload-runs', apiKind, namespace, name],
       }),
       queryClient.refetchQueries({
         queryKey: ['workload-pods', apiKind, namespace, name],
+        ...(apiKind === 'rayclusters' ? { type: 'active' as const } : {}),
       }),
     ])
-  }, [apiKind, name, namespace, queryClient, refetchResource])
+  }, [apiKind, effectiveGroup, name, namespace, queryClient, refetchResource, resource?.spec?.clusterSelector])
   const podWorkloadOwner = useMemo(
     () => podWorkloadOwnerFromRelationships(apiKind, namespace, relationships, resource),
     [apiKind, namespace, relationships, resource],
@@ -761,7 +789,7 @@ export function WorkloadView({
     isLoading: resourceFocusedEventsLoading,
     k8sError: resourceFocusedK8sError,
     updatesError: resourceFocusedUpdatesError,
-  } = useResourceEvents(apiKind, namespace, name)
+  } = useResourceEvents(apiKind, namespace, name, effectiveGroup)
 
   // Fetch all events for this resource's namespace (only when expanded)
   const { data: allEvents, isLoading: eventsLoading } = useChanges({
@@ -868,7 +896,7 @@ export function WorkloadView({
   // the renderer banners. The backend canonicalizes a plural kind via discovery,
   // so using the normalized API kind resolves direct links and app navigation alike.
   const { data: liveIssues, isPending: issuesPending } = useResourceIssues(apiKind, rest.group, namespace, name)
-  const { data: auditFindings } = useResourceAudit(apiKind, namespace, name)
+  const { data: auditFindings } = useResourceAudit(apiKind, namespace, name, effectiveGroup)
   const hasOperationalIssues = Boolean(liveIssues?.length)
   const {
     onCompareTo,
@@ -1169,7 +1197,7 @@ export function WorkloadView({
         // Timeline
         allEvents={allEvents}
         relatedTimelineEvents={relatedTimelineEvents}
-        eventsLoading={eventsLoading || (batchExecution && batchRunsQuery.isLoading)}
+        eventsLoading={eventsLoading || (batchExecution && batchKind !== 'JobSet' && batchRunsQuery.isLoading)}
         topology={topology}
         resourceFocusedK8sEvents={resourceFocusedK8sEvents}
         resourceFocusedUpdates={resourceFocusedUpdates}
@@ -1199,8 +1227,7 @@ export function WorkloadView({
           />
         )}
         renderExpandedOverview={({ kind: k, apiKind, namespace: ns, name: n, resource: res }) =>
-          BATCH_EXECUTION_KINDS.has(k) &&
-          (k !== 'Job' || isCoreBatchJob(apiKind, effectiveGroup)) &&
+          supportsBatchExecution(k, apiKind, effectiveGroup, res?.apiVersion) &&
           res ? (
             <BatchExecutionFullscreen
               kind={k}
@@ -1561,6 +1588,7 @@ const SCHEDULED_LOG_KINDS = new Set([
   'WorkflowTemplate',
   'ClusterWorkflowTemplate',
   'ScaledJob',
+  'JobSet',
 ])
 
 function LogsTabContent({
@@ -1592,7 +1620,7 @@ function LogsTabContent({
   selectedRunKey: string
   onSelectRun: (runKey: string) => void
 }) {
-  if (SCHEDULED_LOG_KINDS.has(kind)) {
+  if (SCHEDULED_LOG_KINDS.has(kind) && supportsBatchExecution(kind, apiKind, group, resource?.apiVersion)) {
     return (
       <div className="h-full">
         <ScheduledWorkloadLogsViewer

package/src/context/ContextSwitchContext.tsx

@@ -1,4 +1,5 @@
-import { createContext, useContext, useState, useCallback, ReactNode } from 'react'
+import { createContext, useContext, useState, useCallback, useRef, ReactNode } from 'react'
+import type { SelectedResource } from '../types'
 
 export interface ParsedContextInfo {
   raw: string
@@ -15,6 +16,11 @@ interface ContextSwitchState {
   startSwitch: (context: ParsedContextInfo) => void
   updateProgress: (message: string) => void
   endSwitch: () => void
+  // A resource to open once a switch to `context` is live. The app's context
+  // reset takes it, so the open can't race the reset that clears the old
+  // cluster's drawer and URL. A change to any other context discards it.
+  setOpenAfterSwitch: (target: { context: string; resource: SelectedResource } | null) => void
+  takeOpenAfterSwitch: (context: string) => SelectedResource | null
 }
 
 const ContextSwitchContext = createContext<ContextSwitchState | null>(null)
@@ -40,8 +46,18 @@ export function ContextSwitchProvider({ children }: { children: ReactNode }) {
     setProgressMessage(null)
   }, [])
 
+  const openAfterSwitch = useRef<{ context: string; resource: SelectedResource } | null>(null)
+  const setOpenAfterSwitch = useCallback((target: { context: string; resource: SelectedResource } | null) => {
+    openAfterSwitch.current = target
+  }, [])
+  const takeOpenAfterSwitch = useCallback((context: string) => {
+    const target = openAfterSwitch.current
+    openAfterSwitch.current = null
+    return target && target.context === context ? target.resource : null
+  }, [])
+
   return (
-    <ContextSwitchContext.Provider value={{ isSwitching, targetContext, progressMessage, startSwitch, updateProgress, endSwitch }}>
+    <ContextSwitchContext.Provider value={{ isSwitching, targetContext, progressMessage, startSwitch, updateProgress, endSwitch, setOpenAfterSwitch, takeOpenAfterSwitch }}>
       {children}
     </ContextSwitchContext.Provider>
   )