@skyhook-io/radar-app 1.14.5 → 1.14.6

package/src/RadarApp.tsx

@@ -84,12 +84,7 @@ export interface RadarAppProps {
    * prefer to share its client rather than nest two providers.
    */
   queryClient?: QueryClient;
-  /**
-   * Slot-based customization of Radar's top nav. Use to inject host-app
-   * brand, replace the kubeconfig context picker with a product-level
-   * cluster switcher, and append items to the right action bar.
-   * See ./context/NavCustomization for the slot shape.
-   */
+  /** Embedded layout and host navigation hooks for Radar Hub. */
   navSlots?: NavCustomization;
   /**
    * Whether Radar may set the browser tab title (`document.title`) per view.
@@ -128,14 +123,14 @@ export interface RadarAppProps {
   /**
    * Initial route for `router: 'memory'` (ignored for 'browser'). Lets a host
    * deep-link a specific view (e.g. '/topology') without owning the URL bar —
-   * used with `navSlots.chrome: 'none'` to render a single per-cluster view
+   * used with `navSlots.embedded: true` to render a single per-cluster view
    * chromeless under the host's own chrome (Radar Hub's per-cluster destinations).
    */
   initialPath?: string;
   /**
    * Reports cluster-data warmup after the main connection is usable. Embedders
    * with their own chrome (Radar Hub) can render this in their topbar while
-   * Radar runs with `navSlots.chrome: 'none'`.
+   * Radar runs with `navSlots.embedded: true`.
    */
   onClusterLoadStateChange?: (state: ClusterLoadState) => void;
   /**

package/src/api/client.jobset.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from 'vitest'
+import { useQuery } from '@tanstack/react-query'
+import { useWorkloadRuns, type WorkloadRunsResponse } from './client'
+
+vi.mock('@tanstack/react-query', async (original) => ({ ...await original<typeof import('@tanstack/react-query')>(), useQuery: vi.fn(() => ({})) }))
+
+describe('JobSet member polling', () => {
+  it('refreshes an active selected member even when the displayed window is idle', () => {
+    useWorkloadRuns('jobsets', 'training', 'distributed', true, { refetchActive: true, role: 'prepare', selected: 'jobs/training/worker' })
+    const options = vi.mocked(useQuery).mock.calls.at(-1)![0]
+    const interval = options.refetchInterval as (query: { state: { data: WorkloadRunsResponse } }) => number
+    const run = { group: 'batch', kind: 'jobs', namespace: 'training', name: 'prepare', phase: 'Succeeded', active: false }
+    const response: WorkloadRunsResponse = { collection: 'members', runs: [run], selected: { ...run, name: 'worker', phase: 'Running', active: true }, total: 2, filteredTotal: 1, truncated: false }
+    expect(interval({ state: { data: response } })).toBe(5000)
+    expect(interval({ state: { data: { ...response, selected: run } } })).toBe(30000)
+    expect(interval({ state: { data: { ...response, runs: [{ ...run, active: true }], selected: undefined } } })).toBe(5000)
+  })
+})

package/src/api/client.resource-identity.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { useQuery } from '@tanstack/react-query'
+import { useResourceAudit, useResourceEvents } from './client'
+
+vi.mock('@tanstack/react-query', async (original) => ({
+  ...await original<typeof import('@tanstack/react-query')>(),
+  useQuery: vi.fn(() => ({})),
+}))
+
+afterEach(() => { vi.clearAllMocks(); vi.unstubAllGlobals() })
+
+describe('resource history identity', () => {
+  it('separates same-name core and Volcano history in requests and cache keys', async () => {
+    const urls: URL[] = []
+    vi.stubGlobal('fetch', vi.fn(async (input: string) => {
+      urls.push(new URL(input, 'http://localhost'))
+      return new Response('[]', {status: 200})
+    }))
+    useResourceEvents('jobs', 'ml', 'shared', 'batch')
+    useResourceEvents('jobs', 'ml', 'shared', 'batch.volcano.sh')
+    const queries = vi.mocked(useQuery).mock.calls.map(call => call[0])
+    expect(queries[0].queryKey).not.toEqual(queries[2].queryKey)
+    expect(queries[1].queryKey).not.toEqual(queries[3].queryKey)
+    for (const query of queries) await (query.queryFn as () => Promise<unknown>)()
+    expect(urls.map(url => url.searchParams.get('group'))).toEqual(['batch', 'batch', 'batch.volcano.sh', 'batch.volcano.sh'])
+    expect(urls.every(url => url.searchParams.get('kind') === 'Job')).toBe(true)
+  })
+
+  it('does not query an unresolved custom identity', () => {
+    useResourceEvents('Widget', 'ml', 'shared')
+    expect(vi.mocked(useQuery).mock.calls.every(call => call[0].enabled === false)).toBe(true)
+  })
+
+  it('preserves a core group and an exact audit group', async () => {
+    const fetchMock = vi.fn<typeof fetch>(async () => new Response('[]', {status: 200}))
+    vi.stubGlobal('fetch', fetchMock)
+    useResourceEvents('pods', 'ml', 'shared', '')
+    await (vi.mocked(useQuery).mock.calls[0][0].queryFn as () => Promise<unknown>)()
+    expect(new URL(String(fetchMock.mock.calls[0][0]), 'http://localhost').searchParams.get('group')).toBe('')
+    useResourceAudit('IngressRoute', 'ml', 'shared', 'traefik.io')
+    await (vi.mocked(useQuery).mock.calls.at(-1)![0].queryFn as () => Promise<unknown>)()
+    expect(fetchMock).toHaveBeenLastCalledWith('/api/audit/resource/IngressRoute/ml/shared?group=traefik.io', expect.anything())
+  })
+})

package/src/api/client.rightsizing.test.ts

@@ -1,21 +1,25 @@
 import { describe, expect, it } from 'vitest'
-import { skipToken } from '@tanstack/react-query'
 import { getRightsizingScanCacheConfig } from './client'
 
 describe('rightsizing scan cache config', () => {
-  it('is manual-only and retained briefly', () => {
+  it('retains result lookups briefly', () => {
     const config = getRightsizingScanCacheConfig(['staging', 'default'], 'cluster-a')
 
-    expect(config.queryFn).toBe(skipToken)
     expect(config.gcTime).toBe(5 * 60 * 1000)
   })
 
+  it('isolates identities', () => {
+    expect(getRightsizingScanCacheConfig([], 'a', 'alice').queryKey).not.toEqual(getRightsizingScanCacheConfig([], 'a', 'bob').queryKey)
+  })
+
   it('normalizes namespace order and isolates cluster and namespace scopes', () => {
     const config = getRightsizingScanCacheConfig(['staging', 'default'], 'cluster-a')
 
     expect(config.namespaceKey).toBe('default,staging')
     expect(config.queryKey).toEqual([
       'prometheus-rightsizing-scan',
+      '/api',
+      '',
       'cluster-a',
       'default,staging',
     ])

package/src/api/client.ts

@@ -1,4 +1,7 @@
+import { canonicalResourceGroup } from '@skyhook-io/k8s-ui/utils/api-resources'
+import { knownKindForPluralWithGroup, pluralToKind } from '@skyhook-io/k8s-ui/utils/navigation'
 import { useEffect, useRef } from 'react'
+import type { KueueAdmissionResponse } from '@skyhook-io/k8s-ui/types/scheduling'
 import type {
   AppHistory,
   AppRow,
@@ -56,7 +59,7 @@ import type {
 } from '../types'
 import type { GitOpsOperationResponse } from '../types/gitops'
 import { apiUrl, getApiBase, getAuthHeaders, getCredentialsMode, getBasename, routePath, stripBasename } from './config'
-import { apiVersionToGroup, pluralToKind } from '../utils/navigation'
+import { apiVersionToGroup } from '../utils/navigation'
 import type { DeploymentMode } from '../types'
 
 // Auto-refresh cadences (ms) — named constants for each polled hook's
@@ -723,10 +726,14 @@ export function useResourceAudit(
   kind: string,
   namespace: string,
   name: string,
+  group?: string,
 ) {
+  const params = new URLSearchParams();
+  if (group) params.set("group", group);
+  const query = params.toString();
   return useQuery<AuditFinding[]>({
-    queryKey: ["audit", "resource", kind, namespace, name],
-    queryFn: () => fetchJSON(`/audit/resource/${kind}/${namespace}/${name}`),
+    queryKey: ["audit", "resource", kind, group ?? "", namespace, name],
+    queryFn: () => fetchJSON(`/audit/resource/${kind}/${namespace}/${name}${query ? `?${query}` : ""}`),
     staleTime: 30000,
   });
 }
@@ -2808,30 +2815,6 @@ export function useChanges(options: UseChangesOptions = {}) {
   });
 }
 
-// Children changes for a parent workload (e.g., ReplicaSets and Pods under a Deployment)
-export function useResourceChildren(
-  kind: string,
-  namespace: string,
-  name: string,
-  timeRange: TimeRange = "1h",
-) {
-  const sinceDate = getTimeRangeDate(timeRange);
-  const params = new URLSearchParams();
-  if (sinceDate) {
-    params.set("since", sinceDate.toISOString());
-  }
-
-  return useQuery<TimelineEvent[]>({
-    queryKey: ["resource-children", kind, namespace, name, timeRange],
-    queryFn: () =>
-      fetchJSON(
-        `/changes/${kind}/${namespace}/${name}/children?${params.toString()}`,
-      ),
-    enabled: Boolean(kind && namespace && name),
-    refetchInterval: 15000, // Refresh every 15 seconds
-  });
-}
-
 export interface ResourceEventsResult {
   k8sEvents: TimelineEvent[];
   updates: TimelineEvent[];
@@ -2850,10 +2833,12 @@ export function useResourceEvents(
   kind: string,
   namespace: string,
   name: string,
+  group?: string,
 ): ResourceEventsResult {
   // The timeline store keys events by their K8s Kind (singular PascalCase, e.g. "Pod"),
   // but callers pass the URL-form kind ("pods").
-  const singularKind = pluralToKind(kind);
+  const singularKind = knownKindForPluralWithGroup(kind, group ?? "") ?? pluralToKind(kind);
+  const resolvedGroup = canonicalResourceGroup(singularKind, group);
   const since = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
 
   // Include managed resources — when viewing a specific resource (e.g. a Pod owned
@@ -2864,18 +2849,19 @@ export function useResourceEvents(
     p.set("namespace", namespace);
     p.set("kind", singularKind);
     p.set("name", name);
+    if (resolvedGroup !== undefined) p.set("group", resolvedGroup);
     p.set("include_managed", "true");
     p.set("since", since);
     return p;
   };
 
-  const enabled = Boolean(kind && namespace && name);
+  const enabled = Boolean(kind && namespace && name && resolvedGroup !== undefined);
 
   // K8s events: high limit so the full set is always returned. The number of
   // distinct K8s events per resource is naturally bounded — kubelet/controllers
   // dedupe via Reason+InvolvedObject and bump count.
   const k8sQuery = useQuery<TimelineEvent[]>({
-    queryKey: ["resource-events", "k8s", singularKind, namespace, name],
+    queryKey: ["resource-events", "k8s", singularKind, resolvedGroup, namespace, name],
     queryFn: async () => {
       const params = baseParams();
       params.set("sources", "k8s_event");
@@ -2889,7 +2875,7 @@ export function useResourceEvents(
   // Resource updates (informer diffs + historical): bounded so a flapping
   // resource doesn't return an unbounded payload.
   const updatesQuery = useQuery<TimelineEvent[]>({
-    queryKey: ["resource-events", "updates", singularKind, namespace, name],
+    queryKey: ["resource-events", "updates", singularKind, resolvedGroup, namespace, name],
     queryFn: async () => {
       const params = baseParams();
       params.set("sources", "informer,historical");
@@ -3272,9 +3258,9 @@ export type PrometheusTimeRange =
   "10m" | "30m" | "1h" | "3h" | "6h" | "12h" | "24h" | "48h" | "7d" | "14d";
 
 // PVC usage at a moment in time, derived from kubelet_volume_stats_*.
-// HasData=false silently indicates the CSI driver doesn't report or Prom
-// isn't scraping kubelet endpoints — UI should hide the gauge in that case.
 export interface PrometheusPVCUsage {
+  // Hub packages the frontend independently from per-cluster agent upgrades.
+  status?: "available" | "no_series" | "invalid_data" | "query_failed";
   namespace: string;
   name: string;
   used: number;
@@ -3364,6 +3350,7 @@ export interface RightsizingScanCoverage {
   workloadsWithData: number;
   batches: number;
   completedBatches: number;
+  attemptedBatches: number;
   restrictedKinds?: string[];
   unavailableKinds?: string[];
   partiallyCachedKinds?: string[];
@@ -3371,6 +3358,11 @@ export interface RightsizingScanCoverage {
 }
 
 export interface RightsizingScanResponse {
+  scanId: string;
+  scanStatus: 'running' | 'finished' | 'cancelled' | 'timed_out';
+  deadlineAt: string;
+  expiresAt?: string;
+  pollAfterSeconds?: number;
   state: RightsizingScanState;
   scannedAt: string;
   window: string;
@@ -3629,7 +3621,6 @@ export function usePrometheusClusterMetrics(
   });
 }
 
-// Fetch PVC usage. hasData=false when no series — UI should hide the gauge.
 export function usePrometheusPVCUsage(
   namespace: string,
   name: string,
@@ -3640,7 +3631,10 @@ export function usePrometheusPVCUsage(
     queryFn: () => fetchJSON(`/prometheus/pvc/${namespace}/${name}`),
     enabled: enabled && Boolean(namespace && name),
     staleTime: 60000,
-    refetchInterval: 120000,
+    refetchInterval: (query) =>
+      isForbiddenError(query.state.error) ? false : 120000,
+    retry: (failureCount, error) =>
+      !isForbiddenError(error) && failureCount < 1,
   });
 }
 
@@ -3663,55 +3657,83 @@ export function usePrometheusRightsizing(
 
 const RIGHTSIZING_SCAN_CACHE_TIME = 5 * 60 * 1000;
 
-export function getRightsizingScanCacheConfig(
-  namespaces: string[],
-  context = "",
-): {
-  namespaceKey: string;
-  queryKey: readonly ["prometheus-rightsizing-scan", string, string];
-  queryFn: typeof skipToken;
-  gcTime: number;
-} {
-  const namespaceKey = [...namespaces].sort().join(",");
+export function getRightsizingScanCacheConfig(namespaces: string[], context = "", identity = "") {
+  const namespaceKey = [...new Set(namespaces)].sort().join(",");
   return {
     namespaceKey,
-    queryKey: ["prometheus-rightsizing-scan", context, namespaceKey] as const,
-    queryFn: skipToken,
+    queryKey: ["prometheus-rightsizing-scan", getApiBase(), identity, context, namespaceKey] as const,
     gcTime: RIGHTSIZING_SCAN_CACHE_TIME,
   };
 }
 
-// A fleet rightsizing scan is intentionally manual. It can query seven days of
-// Prometheus history for many containers, so navigation alone must never run it.
+// Navigation retrieves a retained scan; only an explicit POST starts work.
 export function useRightsizingScan(namespaces: string[], context = "") {
   const queryClient = useQueryClient();
-  const { namespaceKey, ...snapshotOptions } = getRightsizingScanCacheConfig(
-    namespaces,
-    context,
-  );
-  const scanScope = { namespaceKey, queryKey: snapshotOptions.queryKey };
-  const snapshot = useQuery<RightsizingScanResponse>(snapshotOptions);
+  const { data: auth } = useAuthMe();
+  const identity = JSON.stringify([auth?.username, [...(auth?.groups ?? [])].sort()]);
+  const { namespaceKey, ...cache } = getRightsizingScanCacheConfig(namespaces, context, identity);
+  const scope = JSON.stringify(cache.queryKey);
+  const currentScope = useRef(scope);
+  currentScope.current = scope;
+  const previous = useRef<{ scope: string; result: RightsizingScanResponse } | null>(null);
+  const params = new URLSearchParams();
+  if (namespaceKey) params.set('namespaces', namespaceKey);
+  const path = `/prometheus/rightsizing/scan?${params}`;
+  const snapshot = useQuery<RightsizingScanResponse | null>({
+    ...cache,
+    enabled: Boolean(context && auth),
+    queryFn: ({ signal }) => fetchJSON(path, { signal }),
+    refetchOnMount: 'always',
+    retry: (count, error) => !(error instanceof ApiError && [403, 404, 409].includes(error.status)) && count < 1,
+    refetchInterval: (query) => !query.state.error && query.state.data?.scanStatus === 'running' ? 5000 : false,
+  });
   const mutation = useMutation({
-    mutationFn: async (startedScope: typeof scanScope) => {
-      const params = new URLSearchParams();
-      if (startedScope.namespaceKey)
-        params.set("namespaces", startedScope.namespaceKey);
-      const query = params.toString();
-      return fetchJSON<RightsizingScanResponse>(
-        `/prometheus/rightsizing/scan${query ? `?${query}` : ""}`,
-        {
-          method: "POST",
-        },
-      );
+    mutationFn: async (started: { scope: string; path: string; queryKey: typeof cache.queryKey; previousScanId?: string }) => {
+      await queryClient.cancelQueries({ queryKey: started.queryKey });
+      if (currentScope.current !== started.scope) throw new Error('Scan scope changed; run the scan again.');
+      return fetchJSON<RightsizingScanResponse>(started.path, { method: 'POST' });
+    },
+    onSuccess: (result, started) => queryClient.setQueryData(started.queryKey, result),
+    onError: (_error, started) => {
+      // A lost POST response may still have started a scan. Read before retrying.
+      void queryClient.invalidateQueries({ queryKey: started.queryKey });
     },
-    onSuccess: (result, startedScope) =>
-      queryClient.setQueryData(startedScope.queryKey, result),
   });
+  const stop = useMutation({
+    mutationFn: async (started: { id: string; scope: string; queryKey: typeof cache.queryKey }) => {
+      await queryClient.cancelQueries({ queryKey: started.queryKey });
+      if (currentScope.current !== started.scope) throw new Error('Scan scope changed.');
+      return fetchJSON<RightsizingScanResponse>(`/prometheus/rightsizing/scan/${encodeURIComponent(started.id)}`, { method: 'DELETE' });
+    },
+    onSuccess: (result, started) => queryClient.setQueryData(started.queryKey, result),
+  });
+  const inaccessible = snapshot.error instanceof ApiError && [403, 404, 409].includes(snapshot.error.status);
+  const current = inaccessible ? null : snapshot.data;
+  useEffect(() => {
+    if (inaccessible) {
+      previous.current = null;
+      queryClient.setQueryData(cache.queryKey, null);
+    } else if (current && current.coverage.workloadsEvaluated > 0) {
+      previous.current = { scope, result: current };
+    }
+  }, [current, inaccessible, scope, queryClient, cache.queryKey]);
+  const showingPrevious = current?.scanStatus === 'running' && current.coverage.workloadsEvaluated === 0 && previous.current?.scope === scope;
+  const startRecovered = current && current.scanId !== mutation.variables?.previousScanId;
+  const stopRecovered = current && (current.scanId !== stop.variables?.id || current.scanStatus !== 'running');
   return {
-    ...mutation,
-    data: snapshot.data,
-    mutate: () => mutation.mutate(scanScope),
-    mutateAsync: () => mutation.mutateAsync(scanScope),
+    data: showingPrevious ? previous.current!.result : current,
+    progress: current,
+    showingPrevious,
+    isStarting: mutation.isPending,
+    isPending: mutation.isPending || current?.scanStatus === 'running',
+    isLoading: snapshot.isLoading,
+    statusError: snapshot.error,
+    error: snapshot.error || (stop.variables?.scope === scope && !stopRecovered ? stop.error : null) || (mutation.variables?.scope === scope && !startRecovered ? mutation.error : null),
+    reset: () => { mutation.reset(); stop.reset(); },
+    mutateAsync: () => mutation.mutateAsync({ scope, path, queryKey: cache.queryKey, previousScanId: current?.scanId }),
+    retryStatus: () => snapshot.refetch(),
+    stop: () => { if (!mutation.isPending && current?.scanStatus === 'running') stop.mutate({ id: current.scanId, scope, queryKey: cache.queryKey }); },
+    isStopping: stop.isPending,
   };
 }
 
@@ -6443,6 +6465,18 @@ export function useContexts() {
   });
 }
 
+// Where a remote Argo Application or Flux object (spec.kubeConfig) deploys:
+// the destination's host for display, and the kubeconfig contexts that reach it.
+export function useGitOpsDestination(kind: string, namespace: string, name: string, enabled: boolean) {
+  return useQuery<{ server: string; contexts: string[] }>({
+    queryKey: ["gitops-destination", kind, namespace, name],
+    queryFn: () => fetchJSON(`/gitops/destination/${encodeURIComponent(kind)}/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`),
+    enabled,
+    staleTime: 60000,
+    retry: false,
+  });
+}
+
 // Session counts for context switch confirmation
 export interface SessionCounts {
   portForwards: number;
@@ -6737,6 +6771,8 @@ export function useImageFilesystem(
 // Response from workload pods endpoint
 export interface WorkloadPodsResponse {
   pods: WorkloadPodInfo[];
+  total: number;
+  truncated: boolean;
 }
 
 // Response from workload logs endpoint (non-streaming)
@@ -6754,10 +6790,12 @@ export interface WorkloadLogsResponse {
 }
 
 export interface WorkloadRun {
+  group: string;
   kind: string;
   namespace: string;
   name: string;
   phase: string;
+  deleting?: boolean;
   active: boolean;
   startedAt?: string;
   finishedAt?: string;
@@ -6771,6 +6809,7 @@ export interface WorkloadRun {
   parallelism?: number;
   progress?: string;
   template?: string;
+  jobset?: JobSetMember;
   launcher?: {
     kind: string;
     namespace?: string;
@@ -6784,17 +6823,51 @@ export interface WorkloadRun {
   podPending?: number;
 }
 
+export interface JobSetMember {
+  replicatedJob?: string;
+  replicatedJobReplicas?: string;
+  jobIndex?: string;
+  globalReplicas?: string;
+  globalIndex?: string;
+  groupName?: string;
+  groupReplicas?: string;
+  groupIndex?: string;
+  restartAttempt?: string;
+  jobRestartAttempt?: string;
+}
+
 export interface WorkloadRunsResponse {
+  collection: "runs" | "members";
+  filteredTotal?: number;
+  selected?: WorkloadRun;
   runs: WorkloadRun[];
+  total: number;
+  truncated: boolean;
 }
 
 // Fetch pods for a workload
-export function useWorkloadPods(kind: string, namespace: string, name: string) {
+export function useWorkloadPods(
+  kind: string,
+  namespace: string,
+  name: string,
+  options?: { limit?: number; refetchInterval?: number | false; ownerUID?: string; nodeType?: string; workerGroup?: string },
+) {
+  const limit = options?.limit;
+  const params = new URLSearchParams();
+  if (limit) params.set('limit', String(limit));
+  for (const key of ['ownerUID', 'nodeType', 'workerGroup'] as const) {
+    if (options?.[key]) params.set(key, options[key]);
+  }
+  const queryString = params.size ? `?${params}` : '';
+  const ownerKey = options?.ownerUID ? [options.ownerUID, options.nodeType ?? '', options.workerGroup ?? ''] : [];
   return useQuery<WorkloadPodsResponse>({
-    queryKey: ["workload-pods", kind, namespace, name],
-    queryFn: () => fetchJSON(`/workloads/${kind}/${namespace}/${name}/pods`),
+    queryKey: ["workload-pods", kind, namespace, name, limit ?? 0, ...ownerKey],
+    queryFn: () =>
+      fetchJSON(`/workloads/${kind}/${namespace}/${name}/pods${queryString}`),
     enabled: Boolean(kind && namespace && name),
     staleTime: 10000, // 10 seconds - pods can change
+    refetchInterval: options?.refetchInterval ?? false,
+    retry: options?.ownerUID ? (count, error) => !(error instanceof ApiError && error.status === 409) && count < 2 : undefined,
   });
 }
 
@@ -6803,16 +6876,22 @@ export function useWorkloadRuns(
   namespace: string,
   name: string,
   enabled = true,
-  options?: { refetchActive?: boolean; clusterScoped?: boolean },
+  options?: { refetchActive?: boolean; clusterScoped?: boolean; role?: string; search?: string; state?: string; selected?: string },
 ) {
   const clusterScoped = options?.clusterScoped ?? false;
   const ns = clusterScoped ? "_" : namespace;
   const params = new URLSearchParams();
   if (clusterScoped) params.set("clusterScoped", "true");
+  for (const key of ["role", "search", "state", "selected"] as const) { if (options?.[key]) params.set(key, options[key]); }
   const queryString = params.toString();
 
   return useQuery<WorkloadRunsResponse>({
-    queryKey: ["workload-runs", kind, namespace, name, clusterScoped],
+    queryKey: ["workload-runs", kind, namespace, name, clusterScoped, options?.role ?? '', options?.search ?? '', options?.state ?? '', options?.selected ?? ''],
+    placeholderData: (previous, query) => {
+      if (previous?.collection !== 'members') return undefined
+      const identity = ["workload-runs", kind, namespace, name, clusterScoped, options?.role ?? '', options?.search ?? '', options?.state ?? '']
+      return identity.every((value, index) => query?.queryKey[index] === value) ? previous : undefined
+    },
     queryFn: () =>
       fetchJSON(
         `/workloads/${kind}/${ns}/${name}/runs${queryString ? `?${queryString}` : ""}`,
@@ -6821,11 +6900,26 @@ export function useWorkloadRuns(
     staleTime: 10000,
     refetchInterval: options?.refetchActive
       ? (query) =>
-          query.state.data?.runs?.some((run) => run.active) ? 5000 : 30000
+          query.state.data?.selected?.active || query.state.data?.runs?.some((run) => run.active) ? 5000 : 30000
       : false,
   });
 }
 
+export function useKueueAdmission(namespace: string, name: string, uid: string | undefined) {
+  return useQuery<KueueAdmissionResponse>({
+    queryKey: ['kueue-admission', 'jobset.x-k8s.io', namespace, name, uid],
+    queryFn: () => fetchJSON(`/kueue/admission/jobsets/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}?group=jobset.x-k8s.io`),
+    enabled: Boolean(namespace && name && uid),
+    staleTime: 5000,
+    refetchInterval: (query) => {
+      if (query.state.error instanceof ApiError && query.state.error.status < 500) return false
+      if (query.state.data?.uid === uid && query.state.data?.installed === false) return false
+      return 5000
+    },
+    retry: (count, error) => !(error instanceof ApiError && error.status < 500) && count < 2,
+  })
+}
+
 // Fetch logs for a workload (non-streaming)
 export function useWorkloadLogs(
   kind: string,
@@ -7119,3 +7213,64 @@ export function useDiagnostics(enabled: boolean) {
     gcTime: 0,
   });
 }
+
+export interface JobSetUsage {
+  runningPods: number
+  reportingPods: number
+  stalePods: number
+  cpu: number | null
+  memory: number | null
+  cpuRequest: number
+  memoryRequest: number
+  observedAt?: string
+  extendedRequests?: Record<string, string>
+}
+export interface JobSetResources {
+  uid: string
+  total: JobSetUsage
+  members: Record<string, JobSetUsage>
+  source: string
+  unavailable?: string
+}
+export function useJobSetResources(namespace: string, name: string, uid: string | undefined, options: { role: string; search: string; state: string }) {
+  const params = new URLSearchParams()
+  for (const key of ["role", "search", "state"] as const) if (options[key]) params.set(key, options[key])
+  return useQuery<JobSetResources>({
+    queryKey: ['jobset-resources', namespace, name, uid, params.toString()],
+    queryFn: ({ signal }) => fetchJSON(`/jobsets/${namespace}/${name}/resources?${params}`, { signal }),
+    enabled: Boolean(namespace && name && uid),
+    staleTime: 25000,
+    refetchInterval: 30000,
+    retry: false,
+  })
+}
+
+
+export interface KueueProvisioningResponse {
+  uid: string
+  installed: boolean
+  total: number
+  truncated: boolean
+  requests: Array<{
+    apiVersion: string
+    kind: string
+    metadata: { name: string; namespace: string; uid: string; generation?: number; creationTimestamp?: string; deletionTimestamp?: string }
+    spec: { provisioningClassName: string }
+    status?: { conditions: Array<{ type: string; status: string; reason?: string; message?: string; observedGeneration?: number }> }
+  }>
+}
+
+export function useKueueProvisioning(namespace: string, name: string, uid: string | undefined, enabled: boolean) {
+  return useQuery<KueueProvisioningResponse>({
+    queryKey: ['kueue-provisioning', namespace, name, uid],
+    queryFn: () => fetchJSON(`/kueue/provisioning/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`),
+    enabled: enabled && Boolean(namespace && name && uid),
+    staleTime: 5000,
+    refetchInterval: query => {
+      if (query.state.error instanceof ApiError && query.state.error.status < 500) return false
+      if (query.state.data?.uid === uid && query.state.data?.installed === false) return false
+      return 10000
+    },
+    retry: (count, error) => !(error instanceof ApiError && error.status < 500) && count < 2,
+  })
+}