diff --git a/apps/desktop/playwright.config.ts b/apps/desktop/playwright.config.ts
index cd94663..53a2142 100644
--- a/apps/desktop/playwright.config.ts
+++ b/apps/desktop/playwright.config.ts
@@ -1,11 +1,16 @@
 import { defineConfig } from "@playwright/test";
 
+// The preview port is overridable so a local service squatting on the
+// default (e.g. a manual `python -m http.server` previewing apps/landing)
+// cannot silently win reuseExistingServer and serve the wrong app.
+const port = Number(process.env.ASTER_SMOKE_PORT || 4173);
+
 export default defineConfig({
   testDir: "./tests",
   testMatch: "renderer-smoke.spec.ts",
   timeout: 60_000,
   use: {
-    baseURL: "http://127.0.0.1:4173",
+    baseURL: `http://127.0.0.1:${port}`,
   },
   expect: {
     toHaveScreenshot: {
@@ -13,8 +18,8 @@ export default defineConfig({
     },
   },
   webServer: {
-    command: "pnpm build:renderer && pnpm vite preview --host 127.0.0.1 --port 4173 --strictPort",
-    url: "http://127.0.0.1:4173",
+    command: `pnpm build:renderer && pnpm vite preview --host 127.0.0.1 --port ${port} --strictPort`,
+    url: `http://127.0.0.1:${port}`,
     reuseExistingServer: !process.env.CI,
     timeout: 120_000,
   },
diff --git a/apps/desktop/src/renderer/App.tsx b/apps/desktop/src/renderer/App.tsx
index 4950189..a86f54b 100644
--- a/apps/desktop/src/renderer/App.tsx
+++ b/apps/desktop/src/renderer/App.tsx
@@ -4,7 +4,7 @@ import type { AsterSettings, RelatedResource, ResourceKind, ResourceRow, Sources
 import { CommandPalette } from "./components/CommandPalette";
 import { UpdateNotice } from "./components/UpdateNotice";
 import { WelcomeCard } from "./components/WelcomeCard";
-import { ResourceTable, rowKey, TableState } from "./components/ResourceTable";
+import { ResourceTable, podUsageKey, rowKey, TableState } from "./components/ResourceTable";
 import { Button } from "@/components/ui/button";
 import {
   AlertDialog,
@@ -31,7 +31,11 @@ import { useTheme } from "./hooks/useTheme";
 import { useUpdater } from "./hooks/useUpdater";
 import { buildCommandItems, objectCommandItems, searchResultItems, type CommandAction } from "./lib/command-palette";
 import { messageOf, pluralize } from "./lib/format";
+import { namespaceScopeKey, namespaceScopeSummary } from "./lib/namespace-scope";
+import { SLOW_POLL_MS } from "./lib/poll-cadence";
+import { isRolloutWorkloadKind } from "./detail/workload-detail";
 import { customResourceGroups, DEFAULT_KIND, findKindInGroups, flattenResourceGroups, SIDEBAR_RESOURCE_GROUPS } from "./lib/resource-catalog";
+import { mostUsedKindIds, recordKindUsage, toggleFavoriteKind } from "./lib/resource-favorites";
 import { Sidebar, type SidebarToolGroup } from "./shell/Sidebar";
 import { UnifiedToolbar } from "./shell/UnifiedToolbar";
 import { WorkbenchShell } from "./shell/WorkbenchShell";
@@ -70,19 +74,37 @@ export default function App() {
   }, [contextId, core.state]);
   const [kind, setKind] = useState<ResourceKind>(DEFAULT_KIND);
   const namespaces = useNamespaces(contextId, contexts.contexts, setError);
+  const { namespaceScope } = namespaces;
+  // Order-insensitive identity of the scope; reset effects and cache keys
+  // compare this so [a, b] and [b, a] count as the same scope.
+  const scopeKey = useMemo(() => namespaceScopeKey(namespaceScope), [namespaceScope]);
+  // Row-scoped surfaces (create dialog, palette search fallback) only have a
+  // namespace when the scope names exactly one.
+  const primaryNamespace = namespaceScope.length === 1 ? namespaceScope[0] : "";
+  // The create dialog pre-fills a namespace the user actually chose (#31
+  // story 24): the single-selection scope first, else the context's default
+  // for All/multi scopes; the template's literal "default" remains the last
+  // resort for contexts without one.
+  const createNamespace = primaryNamespace
+    || contexts.contexts.find((item) => item.id === contextId)?.namespace
+    || "";
   const resources = useResourceList({
     contextId,
     kind,
-    namespace: namespaces.namespace,
+    namespaceScope,
     coreReady: core.state === "ready",
     setError,
   });
   const detail = useResourceDetail({
     contextId,
     kind,
-    namespace: namespaces.namespace,
+    scopeKey,
     generation: resources.generation,
     items: resources.list.items,
+    coreReady: core.state === "ready",
+    // The single-object live channel is a rollout-workload feature (#39);
+    // every other kind keeps the pre-existing selection-follows-list flow.
+    live: isRolloutWorkloadKind(kind.kind),
   });
   const diagnostics = useDiagnostics({
     contextId,
@@ -92,7 +114,7 @@ export default function App() {
   const mutation = useMutation({
     contextId,
     kind,
-    namespace: namespaces.namespace,
+    namespace: primaryNamespace,
     selected: detail.selected,
   });
   const [overviewActive, setOverviewActive] = useState(false);
@@ -104,16 +126,18 @@ export default function App() {
   const [helmActive, setHelmActive] = useState(false);
   const helm = useHelm({
     contextId,
-    namespace: namespaces.namespace,
+    namespaceScope,
     coreReady: core.state === "ready" && helmActive,
   });
 
   // Live CPU/memory readouts for the Pod table. Only fetched while the Pod
   // kind is the active pane and the list is namespace-scoped, so a browse
-  // through other kinds never touches metrics.k8s.io.
+  // through other kinds never touches metrics.k8s.io. A multi-namespace scope
+  // issues one ordinary per-namespace call on the same 15s cadence; a failed
+  // namespace degrades to "no usage for its rows".
   const [podUsage, setPodUsage] = useState<ReadonlyMap<string, { cpu?: string; memory?: string }>>(new Map());
   const [podUsageError, setPodUsageError] = useState("");
-  const podPaneActive = kind.id === "pods" && !overviewActive && !helmActive && Boolean(namespaces.namespace);
+  const podPaneActive = kind.id === "pods" && !overviewActive && !helmActive && namespaceScope.length > 0;
   useEffect(() => {
     if (!podPaneActive || !contextId) {
       setPodUsage(new Map());
@@ -121,31 +145,61 @@ export default function App() {
       return;
     }
     let active = true;
+    const scope = namespaceScope;
     const fetchMetrics = async () => {
-      try {
-        const metrics = await desktop.metrics.pods(contextId, namespaces.namespace);
-        if (!active) return;
-        setPodUsage(new Map(metrics.map((pod) => {
+      const results = await Promise.all(scope.map(async (namespace) => {
+        try {
+          return { namespace, metrics: await desktop.metrics.pods(contextId, namespace), failed: false as const };
+        } catch (cause) {
+          return { namespace, metrics: [], failed: true as const, message: messageOf(cause) };
+        }
+      }));
+      if (!active) return;
+      // Only an outage across the whole scope surfaces as a table error;
+      // partial failures just leave those rows without usage.
+      const failures = results.filter((result) => result.failed);
+      setPodUsageError(failures.length === scope.length && failures.length > 0 ? failures[0].message : "");
+      const usage = new Map<string, { cpu?: string; memory?: string }>();
+      for (const { namespace, metrics } of results) {
+        for (const pod of metrics) {
           const cpu = pod.containers.map((container) => container.cpu).find((value) => value);
           const memory = pod.containers.map((container) => container.memory).find((value) => value);
-          return [pod.name, { cpu, memory }];
-        })));
-        setPodUsageError("");
-      } catch (cause) {
-        if (active) setPodUsageError(messageOf(cause));
+          usage.set(podUsageKey(pod.namespace || namespace, pod.name), { cpu, memory });
+        }
       }
+      setPodUsage(usage);
     };
     void fetchMetrics();
-    const timer = setInterval(() => void fetchMetrics(), 15_000);
+    const timer = setInterval(() => void fetchMetrics(), SLOW_POLL_MS);
     return () => {
       active = false;
       clearInterval(timer);
     };
-  }, [podPaneActive, contextId, namespaces.namespace, kind.id]);
+  }, [podPaneActive, contextId, namespaceScope, kind.id]);
   const helmToolGroups: SidebarToolGroup[] = useMemo(() => [{
     label: "Helm",
     items: [{ id: "helm", label: "Releases", icon: Ship }],
   }], []);
+
+  // Sidebar quick access (#competitor parity): starred kinds and the kinds
+  // this operator actually opens most. UI preferences like the sidebar fold
+  // prefs — localStorage, renderer-side, no cluster data.
+  const [favoriteKinds, setFavoriteKinds] = useState<string[]>(() => readStoredStringList("aster.sidebar.favoriteKinds"));
+  const [kindUsage, setKindUsage] = useState<Record<string, number>>(() => readStoredUsage("aster.sidebar.kindUsage"));
+  useEffect(() => {
+    localStorage.setItem("aster.sidebar.favoriteKinds", JSON.stringify(favoriteKinds));
+  }, [favoriteKinds]);
+  useEffect(() => {
+    localStorage.setItem("aster.sidebar.kindUsage", JSON.stringify(kindUsage));
+  }, [kindUsage]);
+  const toggleFavorite = useCallback((id: string) => {
+    setFavoriteKinds((current) => toggleFavoriteKind(current, id));
+  }, []);
+  // Starred kinds need no second pointer in Most used; the top three fill it.
+  const mostUsed = useMemo(
+    () => mostUsedKindIds(kindUsage, new Set(favoriteKinds), 3),
+    [kindUsage, favoriteKinds],
+  );
   const searchRef = useRef<HTMLInputElement>(null);
   const [paletteOpen, setPaletteOpen] = useState(false);
   const [createOpen, setCreateOpen] = useState(false);
@@ -188,7 +242,7 @@ export default function App() {
   const [checkedKeys, setCheckedKeys] = useState<ReadonlySet<string>>(new Set());
   useEffect(() => {
     setCheckedKeys(new Set());
-  }, [contextId, kind.id, namespaces.namespace]);
+  }, [contextId, kind.id, scopeKey]);
   const checkedRows = useMemo(
     () => resources.visibleRows.filter((row) => checkedKeys.has(rowKey(row))),
     [resources.visibleRows, checkedKeys],
@@ -248,9 +302,11 @@ export default function App() {
 
   // Selecting a resource kind always leaves the overview and the Helm pane;
   // the kind switches only when it differs, otherwise the row selection resets.
+  // Every open feeds the Most used ranking, whichever surface triggered it.
   const selectKind = useCallback((next: ResourceKind) => {
     setOverviewActive(false);
     setHelmActive(false);
+    setKindUsage((usage) => recordKindUsage(usage, next.id));
     if (next.id === kind.id) {
       detail.clear();
       return;
@@ -279,10 +335,12 @@ export default function App() {
     if (!match) return;
     const { icon: _icon, label: _label, enabled: _enabled, ...nextKind } = match;
     const namespace = target.namespace || "";
-    if (namespace !== namespaces.namespace) namespaces.setNamespace(namespace);
+    // Palette/related navigation pins the scope to the one target namespace,
+    // replacing any multi-selection so the pending row cannot get lost.
+    if (!(namespaceScope.length === 1 && namespaceScope[0] === namespace)) namespaces.setNamespaceScope(namespace ? [namespace] : []);
     setPendingSelect({ name: target.name, namespace });
     selectKind(nextKind);
-  }, [resourceGroups, namespaces, selectKind]);
+  }, [resourceGroups, namespaceScope, namespaces, selectKind]);
 
   useEffect(() => {
     if (!pendingSelect) return;
@@ -304,7 +362,7 @@ export default function App() {
       desktop.resources.search({
         contextId,
         query,
-        namespace: namespaces.namespace || contexts.activeContext?.namespace || "default",
+        namespace: primaryNamespace || contexts.activeContext?.namespace || "default",
       })
         .then((items) => { if (active) setSearchResults(items); })
         .catch(() => { if (active) setSearchResults([]); });
@@ -313,7 +371,7 @@ export default function App() {
       active = false;
       clearTimeout(timer);
     };
-  }, [paletteQuery, paletteOpen, contextId, namespaces.namespace, contexts.activeContext]);
+  }, [paletteQuery, paletteOpen, contextId, primaryNamespace, contexts.activeContext]);
 
   // A stale result set is cleared when the palette closes or the query resets.
   useEffect(() => {
@@ -324,7 +382,7 @@ export default function App() {
     const target = targetId ? contexts.contexts.find((item) => item.id === targetId) : contexts.chosenContext;
     if (!target || target.error || core.state !== "ready") return;
     setError("");
-    namespaces.setNamespace(target.namespace || "");
+    namespaces.setNamespaceScope(target.namespace ? [target.namespace] : []);
     contexts.setContextChoice(target.id);
     void setPortForwardContext(target.id).catch((cause) => setError(messageOf(cause)));
     contexts.setContextId(target.id);
@@ -340,7 +398,7 @@ export default function App() {
     contexts.setContextQuery("");
     void setPortForwardContext("").catch((cause) => setError(messageOf(cause)));
     contexts.setContextId("");
-    namespaces.setNamespace("");
+    namespaces.setNamespaceScope([]);
     resources.setQuery("");
     detail.clear();
     resources.reset();
@@ -400,14 +458,14 @@ export default function App() {
       namespaces: namespaces.namespaces,
       namespacesLoading: namespaces.loading,
       namespacesTruncated: namespaces.truncated,
-      activeNamespace: namespaces.namespace,
+      activeNamespace: primaryNamespace,
       theme,
     });
     // Linear-style contextual mode: while a row is selected, the palette leads
     // with object-scoped commands under a "Selected object" group.
     if (detail.selected) return [...objectCommandItems(detail.selected), ...base];
     return base;
-  }, [core.state, contexts.contexts, contextId, resourceGroups, kind.id, namespaces.namespaces, namespaces.loading, namespaces.namespace, theme, detail.selected]);
+  }, [core.state, contexts.contexts, contextId, resourceGroups, kind.id, namespaces.namespaces, namespaces.loading, primaryNamespace, theme, detail.selected]);
 
   const executePaletteCommand = useCallback((action: CommandAction) => {
     switch (action.type) {
@@ -421,7 +479,8 @@ export default function App() {
         connectContext(action.contextId);
         return;
       case "select-namespace":
-        namespaces.setNamespace(action.namespace);
+        // Palette navigation stays deterministic: it replaces any selection.
+        namespaces.setNamespaceScope([action.namespace]);
         return;
       case "set-theme":
         setTheme(action.theme);
@@ -593,6 +652,9 @@ export default function App() {
           onSelectTool={(toolId) => {
             if (toolId === "helm") showHelm();
           }}
+          favoriteKindIds={favoriteKinds}
+          onToggleFavoriteKind={toggleFavorite}
+          mostUsedKindIds={mostUsed}
           onShowContexts={showContextPicker}
         />
       )}
@@ -602,9 +664,9 @@ export default function App() {
           namespacesTruncated={namespaces.truncated}
           namespacesLoading={namespaces.loading}
           namespacesLoaded={namespaces.loaded}
-          namespace={namespaces.namespace}
+          namespaceScope={namespaceScope}
           onNamespaceOpen={namespaces.load}
-          onNamespaceChange={namespaces.setNamespace}
+          onNamespaceScopeChange={namespaces.setNamespaceScope}
           namespaceDisabled={overviewActive || (!helmActive && !kind.namespaced)}
           query={helmActive || overviewActive ? "" : resources.query}
           onQueryChange={helmActive || overviewActive ? () => undefined : resources.setQuery}
@@ -639,7 +701,7 @@ export default function App() {
           {helmActive && (
             <HelmView
               contextName={contexts.activeContext?.name}
-              namespace={namespaces.namespace}
+              scopeLabel={namespaceScopeSummary(namespaceScope) || "All namespaces"}
               releases={helm.releases}
               progress={helm.progress}
               onCancel={helm.cancel}
@@ -664,7 +726,9 @@ export default function App() {
               <div>
                 <h1>{pluralize(kind.kind)}</h1>
                 <p>{kind.category} · {contexts.activeContext?.name || "Kubernetes"}
-                  {resources.snapshotOnly ? " · All namespaces (snapshot, refresh to update)" : ""}
+                  {resources.snapshotOnly ? (namespaceScope.length > 1
+                    ? ` · ${namespaceScope.length} namespaces (snapshot, refresh to update)`
+                    : " · All namespaces (snapshot, refresh to update)") : ""}
                   {resources.revalidating ? " · Refreshing…" : ""}
                 </p>
               </div>
@@ -802,7 +866,7 @@ export default function App() {
             open={createOpen}
             onOpenChange={setCreateOpen}
             kind={kind}
-            namespace={namespaces.namespace}
+            namespace={createNamespace}
             busy={mutation.mutationBusy}
             message={mutation.mutationMessage}
             preview={mutation.mutationPreview}
@@ -818,3 +882,27 @@ export default function App() {
     </WorkbenchShell>
   );
 }
+
+/** Reads a stored string array; corrupt or foreign payloads degrade to empty. */
+function readStoredStringList(key: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(localStorage.getItem(key) || "[]");
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "string")
+      ? parsed as string[]
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Reads a stored string→number counter map; corrupt payloads degrade to empty. */
+function readStoredUsage(key: string): Record<string, number> {
+  try {
+    const parsed: unknown = JSON.parse(localStorage.getItem(key) || "{}");
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const entries = Object.entries(parsed).filter(([, count]) => typeof count === "number");
+    return Object.fromEntries(entries);
+  } catch {
+    return {};
+  }
+}
diff --git a/apps/desktop/src/renderer/components/ResourceTable.tsx b/apps/desktop/src/renderer/components/ResourceTable.tsx
index 3e4ae10..c9c3d88 100644
--- a/apps/desktop/src/renderer/components/ResourceTable.tsx
+++ b/apps/desktop/src/renderer/components/ResourceTable.tsx
@@ -13,6 +13,15 @@ export function rowKey(row: ResourceRow): string {
   return row.uid || `${row.namespace}/${row.name}`;
 }
 
+/**
+ * Identity of a pod's usage entry: namespace/name rather than uid, because
+ * metrics.k8s.io responses carry no uid and the same pod name in two
+ * selected namespaces must not trade usage rows.
+ */
+export function podUsageKey(namespace: string, name: string): string {
+  return `${namespace}/${name}`;
+}
+
 export function ResourceTable({ rows, selected, checkedRows, onToggleRow, onToggleAll, hasMore, loadingMore, onLoadMore, loading, error, onSelect, podMetrics }: {
   rows: ResourceRow[];
   selected?: ResourceRow;
@@ -25,7 +34,7 @@ export function ResourceTable({ rows, selected, checkedRows, onToggleRow, onTogg
   loading: boolean;
   error: string;
   onSelect(row: ResourceRow): void;
-  /** Live CPU/memory totals keyed by pod name; present only for the Pod kind. */
+  /** Live CPU/memory totals keyed by namespace/name; present only for the Pod kind. */
   podMetrics?: ReadonlyMap<string, { cpu?: string; memory?: string }>;
 }) {
   const viewport = useRef<HTMLDivElement>(null);
@@ -147,7 +156,7 @@ export function ResourceTable({ rows, selected, checkedRows, onToggleRow, onTogg
             const row = rows[virtualRow.index];
             const active = selected?.uid === row.uid;
             const checked = checkedRows.has(rowKey(row));
-            const usage = podMetrics?.get(row.name);
+            const usage = podMetrics?.get(podUsageKey(row.namespace, row.name));
             return (
               <div
                 role="row"
diff --git a/apps/desktop/src/renderer/detail/DetailHeader.tsx b/apps/desktop/src/renderer/detail/DetailHeader.tsx
index 7dd0ac7..bf3321d 100644
--- a/apps/desktop/src/renderer/detail/DetailHeader.tsx
+++ b/apps/desktop/src/renderer/detail/DetailHeader.tsx
@@ -12,9 +12,12 @@ import {
 import type { ResourceRow } from "../../shared/types";
 import { findCatalogIcon } from "../lib/resource-catalog";
 import type { ResourceActionDescriptor, ResourceActionId } from "./resource-actions";
+import type { RolloutStatus } from "./workload-detail";
 
 export interface DetailHeaderProps {
   row: ResourceRow;
+  /** Live rollout state for workload kinds; absent when there is nothing to say. */
+  rollout?: RolloutStatus;
   actions: ResourceActionDescriptor[];
   canMutate: boolean;
   mutationBusy: boolean;
@@ -31,6 +34,7 @@ export interface DetailHeaderProps {
  */
 export function DetailHeader({
   row,
+  rollout,
   actions,
   canMutate,
   mutationBusy,
@@ -59,6 +63,7 @@ export function DetailHeader({
           <div className="resource-detail-title-row">
             <h1 title={row.name}>{row.name}</h1>
             <StatusBadge status={row.status} deleting={row.deleting} />
+            {rollout && <RolloutBadge rollout={rollout} />}
           </div>
         </div>
 
@@ -181,3 +186,34 @@ export function StatusBadge({ status, deleting }: { status?: string; deleting?:
     </Badge>
   );
 }
+
+/** One row per rollout state: label, badge tone, and icon travel together. */
+const ROLLOUT_BADGE: Record<RolloutStatus["state"], {
+  label: string;
+  variant: "destructive" | "secondary" | "outline";
+  Icon: typeof Clock3;
+}> = {
+  progressing: { label: "Rollout in progress", variant: "outline", Icon: Clock3 },
+  complete: { label: "Rolled out", variant: "secondary", Icon: CheckCircle2 },
+  stuck: { label: "Rollout stuck", variant: "destructive", Icon: AlertCircle },
+};
+
+/**
+ * The rollout chip: distinguishes "rolling out" from "rolled out" and
+ * "stuck" so live updates have somewhere to land at a glance. Tone rides
+ * with text, never color alone.
+ */
+function RolloutBadge({ rollout }: { rollout: RolloutStatus }) {
+  const { label, variant, Icon } = ROLLOUT_BADGE[rollout.state];
+  return (
+    <Badge
+      className="resource-status-badge"
+      variant={variant}
+      title={rollout.message}
+      data-testid="rollout-status"
+    >
+      <Icon aria-hidden="true" />
+      {label}
+    </Badge>
+  );
+}
diff --git a/apps/desktop/src/renderer/detail/ResourceDetailView.tsx b/apps/desktop/src/renderer/detail/ResourceDetailView.tsx
index 71c16b5..976cb2c 100644
--- a/apps/desktop/src/renderer/detail/ResourceDetailView.tsx
+++ b/apps/desktop/src/renderer/detail/ResourceDetailView.tsx
@@ -34,6 +34,7 @@ import { Tabs, TabsContent, TabsList, TabsTrigger } from "../components/ui/tabs"
 import { usePodMetrics } from "../hooks/usePodMetrics";
 import { useResourceList } from "../hooks/useResourceList";
 import { findEnabledResourceKind } from "../lib/resource-catalog";
+import { newestEventsFirst } from "../lib/resource-events";
 import { DetailHeader } from "./DetailHeader";
 import { LogViewer } from "./LogViewer";
 import { MutationDiffView } from "./MutationDiffView";
@@ -43,8 +44,9 @@ import { extractForwardPorts } from "./port-forward-ports";
 import { resourceActionsFor, type ResourceActionId } from "./resource-actions";
 import { formatTimestamp } from "./resource-format";
 import { HighlightedYaml } from "./yaml-highlight";
-import { parseWorkloadDetails, podSelector } from "./workload-detail";
+import { parseWorkloadDetails, podSelector, rolloutStatus } from "./workload-detail";
 import { WorkloadPodsPanel } from "./WorkloadPodsPanel";
+import { usePodEvents } from "../hooks/usePodEvents";
 
 type MutationDraft = Omit<
   ResourceMutationRequest,
@@ -171,7 +173,7 @@ export function ResourceDetailView({
   const pods = useResourceList({
     contextId,
     kind: POD_KIND,
-    namespace: row?.namespace ?? "",
+    namespaceScope: row?.namespace ? [row.namespace] : [],
     coreReady,
     setError: setPodsError,
     labelSelector: selector,
@@ -193,6 +195,19 @@ export function ResourceDetailView({
     isPod ? row?.namespace ?? "" : "",
     isPod ? row?.name ?? "" : "",
   );
+  // The rollout's child pod events (Pulling / Created / Started / Killing),
+  // joined to this workload's own pods; one polled list request, never a
+  // watch stream or a per-pod fan-out.
+  const podNames = useMemo(() => pods.visibleRows.map((pod) => pod.name), [pods.visibleRows]);
+  const podEvents = usePodEvents({
+    contextId,
+    namespace: row?.namespace ?? "",
+    names: podNames,
+    enabled: Boolean(workload && selector),
+  });
+  // The Events surface merges the object's own events (ScalingReplicaSet)
+  // with its pods' events, newest first, so a rollout reads as one timeline.
+  const allEvents = useMemo(() => mergeEvents(events, podEvents), [events, podEvents]);
 
   if (!row) {
     return (
@@ -213,6 +228,9 @@ export function ResourceDetailView({
   const actions = resourceActionsFor(currentRow.kind);
   const actionIds = new Set(actions.map((action) => action.id));
   const showLogs = currentRow.kind === "Pod" || isWorkloadLogKind(currentRow.kind);
+  // At-a-glance rollout state (in progress / complete / stuck) from the live
+  // Progressing condition plus the replica counters.
+  const rollout = rolloutStatus(details, currentRow);
   const podsLoading = (!detail && !detailError) || pods.loading;
   const podsFailure = detailError || podsError;
   const podsPreview: PodsPreview | undefined = !workload ? undefined : {
@@ -276,6 +294,7 @@ export function ResourceDetailView({
     <section className="resource-detail-view" data-testid="resource-detail-view">
       <DetailHeader
         row={currentRow}
+        rollout={rollout}
         actions={actions}
         canMutate={canMutate}
         mutationBusy={mutationBusy}
@@ -299,7 +318,7 @@ export function ResourceDetailView({
           {showLogs && <TabsTrigger value="logs">Logs</TabsTrigger>}
           <TabsTrigger value="yaml">YAML</TabsTrigger>
           <TabsTrigger value="events">
-            Events{events.length ? ` (${events.length})` : ""}
+            Events{allEvents.length ? ` (${allEvents.length})` : ""}
           </TabsTrigger>
           <TabsTrigger value="related">
             Related{related.length ? ` (${related.length})` : ""}
@@ -312,7 +331,7 @@ export function ResourceDetailView({
               row={currentRow}
               details={details}
               journal={journal}
-              events={events}
+              events={allEvents}
               related={related}
               pods={podsPreview}
               metrics={isPod ? metrics : undefined}
@@ -375,7 +394,7 @@ export function ResourceDetailView({
           </TabsContent>
 
           <TabsContent value="events" className="resource-detail-padded-tab">
-            <EventsView events={events} />
+            <EventsView events={allEvents} />
           </TabsContent>
 
           <TabsContent value="related" className="resource-detail-padded-tab">
@@ -635,6 +654,26 @@ function EmptyTab({ icon, title, detail }: { icon: React.ReactNode; title: strin
   return <div className="resource-tab-empty">{icon}<h2>{title}</h2><p>{detail}</p></div>;
 }
 
+/** Bound of the merged events timeline; matches the events one-shot's page cap. */
+const MERGED_EVENT_LIMIT = 100;
+
+/**
+ * Merges the open object's own events with its child pods' events, newest
+ * first. The object's one-shot fetch and the pod-events poll replace their
+ * halves wholesale, so a plain dedupe-and-sort keeps the timeline stable.
+ */
+function mergeEvents(objectEvents: ResourceEvent[], podEvents: ResourceEvent[]): ResourceEvent[] {
+  const seen = new Set<string>();
+  const deduped: ResourceEvent[] = [];
+  for (const event of [...objectEvents, ...podEvents]) {
+    const key = `${event.namespace}/${event.name}|${event.reason || ""}|${event.lastTimestamp || ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(event);
+  }
+  return newestEventsFirst(deduped, MERGED_EVENT_LIMIT);
+}
+
 function OperationInputDialog({
   kind,
   value,
diff --git a/apps/desktop/src/renderer/detail/workload-detail.test.ts b/apps/desktop/src/renderer/detail/workload-detail.test.ts
index 73a2181..dfa3d24 100644
--- a/apps/desktop/src/renderer/detail/workload-detail.test.ts
+++ b/apps/desktop/src/renderer/detail/workload-detail.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { parseWorkloadDetails, podSelector } from "./workload-detail";
+import { parseWorkloadDetails, podSelector, rolloutStatus } from "./workload-detail";
 
 const DEPLOYMENT = `
 apiVersion: apps/v1
@@ -143,3 +143,124 @@ describe("podSelector", () => {
     expect(podSelector(parseWorkloadDetails(DEPLOYMENT))).toBe("app=brain-ui,tier=web");
   });
 });
+
+describe("rolloutStatus", () => {
+  const details = parseWorkloadDetails(DEPLOYMENT)!;
+
+  it("Progressing=True with NewReplicaSetAvailable is complete", () => {
+    const progressing = {
+      type: "Progressing",
+      status: "True",
+      reason: "NewReplicaSetAvailable",
+      message: "Deployment has minimum availability.",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [progressing] };
+    expect(withCondition.conditions).toHaveLength(1);
+    expect(rolloutStatus(withCondition, { desired: 2, ready: 2, updated: 2 })).toEqual({
+      state: "complete",
+      message: "NewReplicaSetAvailable · 2/2 ready · 2 updated",
+    });
+  });
+
+  it("Progressing=True mid-rollout is progressing with the replica counters", () => {
+    const progressing = {
+      type: "Progressing",
+      status: "True",
+      reason: "ReplicaSetUpdated",
+      message: "ReplicaSet is progressing.",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [progressing] };
+    expect(withCondition.conditions).toHaveLength(1);
+    expect(rolloutStatus(withCondition, { desired: 5, ready: 2, updated: 2 })).toEqual({
+      state: "progressing",
+      message: "ReplicaSetUpdated · 2/5 ready · 2 updated",
+    });
+  });
+
+  it("Progressing=False is stuck (progress deadline exceeded)", () => {
+    const failing = {
+      type: "Progressing",
+      status: "False",
+      reason: "ProgressDeadlineExceeded",
+      message: "Progress deadline exceeded.",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [failing] };
+    expect(rolloutStatus(withCondition, { desired: 2, ready: 1, updated: 1 })).toEqual({
+      state: "stuck",
+      message: "ProgressDeadlineExceeded · 1/2 ready · 1 updated",
+    });
+  });
+
+  it("settled counters complete a non-terminal Progressing=True (StatefulSet)", () => {
+    // StatefulSet keeps Progressing=True with a reason like SuccessfulCreate
+    // long after the rollout settles; only the counters can say it is done.
+    const progressing = {
+      type: "Progressing",
+      status: "True",
+      reason: "SuccessfulCreate",
+      message: "create Pod db-0 in StatefulSet db successful",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [progressing] };
+    expect(rolloutStatus(withCondition, { desired: 3, ready: 3, updated: 3 })).toEqual({
+      state: "complete",
+      message: "3/3 ready · 3 updated",
+    });
+  });
+
+  it("lagging updated replicas keep a settled-ready rollout progressing", () => {
+    // Mid-rollout with maxUnavailable=0, ready can sit at desired while the
+    // new revision is still rolling: updated < desired must override.
+    const progressing = {
+      type: "Progressing",
+      status: "True",
+      reason: "ReplicaSetUpdated",
+      message: "ReplicaSet is progressing.",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [progressing] };
+    expect(rolloutStatus(withCondition, { desired: 3, ready: 3, updated: 1 })).toEqual({
+      state: "progressing",
+      message: "ReplicaSetUpdated · 3/3 ready · 1 updated",
+    });
+  });
+
+  it("unknown counters fall back to the condition alone", () => {
+    const progressing = {
+      type: "Progressing",
+      status: "True",
+      reason: "SuccessfulCreate",
+      message: "create Pod db-0 in StatefulSet db successful",
+      lastTransitionTime: "2026-08-12T13:49:39Z",
+    };
+    const withCondition = { ...details, conditions: [progressing] };
+    expect(rolloutStatus(withCondition, { desired: undefined, ready: undefined })).toEqual({
+      state: "progressing",
+      message: "SuccessfulCreate",
+    });
+  });
+
+  it("without a condition, lagging replicas mean progressing", () => {
+    const none = { ...details, conditions: [] };
+    expect(rolloutStatus(none, { desired: 3, ready: 1 })).toEqual({
+      state: "progressing",
+      message: "1/3 ready",
+    });
+  });
+
+  it("without a condition, fully ready replicas mean complete", () => {
+    const none = { ...details, conditions: [] };
+    expect(rolloutStatus(none, { desired: 3, ready: 3, updated: 3 })).toEqual({
+      state: "complete",
+      message: "3/3 ready · 3 updated",
+    });
+  });
+
+  it("objects without rollout semantics return undefined", () => {
+    expect(rolloutStatus(undefined, {})).toBeUndefined();
+    expect(rolloutStatus({ ...details, conditions: [] }, { desired: undefined, ready: undefined })).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/renderer/detail/workload-detail.ts b/apps/desktop/src/renderer/detail/workload-detail.ts
index e460922..527ce29 100644
--- a/apps/desktop/src/renderer/detail/workload-detail.ts
+++ b/apps/desktop/src/renderer/detail/workload-detail.ts
@@ -1,4 +1,5 @@
 import { parse } from "yaml";
+import type { ResourceRow } from "../../shared/types";
 
 export interface WorkloadCondition {
   type: string;
@@ -106,6 +107,85 @@ export function podSelector(details: WorkloadDetails | undefined): string | unde
   return details.selector;
 }
 
+export type RolloutState = "progressing" | "complete" | "stuck";
+
+/**
+ * Kinds whose open detail keeps a single-object live channel (#39): the
+ * pod-owning controllers with rollout semantics. Everything else — Pods,
+ * ConfigMaps, cluster-scoped kinds — keeps the pre-existing behavior (the
+ * list watch bumps the selection; snapshot scopes stay frozen), so no watch
+ * request ever leaves with an empty namespace.
+ */
+export function isRolloutWorkloadKind(kind: string): boolean {
+  return kind === "Deployment" || kind === "StatefulSet" || kind === "DaemonSet"
+    || kind === "ReplicaSet" || kind === "ReplicationController";
+}
+
+export interface RolloutStatus {
+  state: RolloutState;
+  /** Short human summary, e.g. "2/5 ready · 1 updated" or the condition reason. */
+  message: string;
+}
+
+/**
+ * Derives the rollout state from the Progressing condition plus the replica
+ * counters, so "in progress / complete / stuck" is visible at a glance while
+ * a rollout runs. The counters come from the live row, the condition from the
+ * live YAML — both converge through the detail's single-object watch.
+ * Counters decide completion whenever they are known: StatefulSet keeps
+ * Progressing=True with a non-terminal reason long after it settles, so only
+ * "ready == desired and updated == desired" can mark it complete (and lagging
+ * counters keep an optimistic condition honest mid-rollout).
+ * Returns undefined for objects without rollout semantics (no usable
+ * condition and no replica counters, e.g. Pods, ConfigMaps, Jobs without
+ * spec.replicas).
+ */
+export function rolloutStatus(
+  details: WorkloadDetails | undefined,
+  row: Pick<ResourceRow, "desired" | "ready" | "updated">,
+): RolloutStatus | undefined {
+  const condition = details?.conditions.find((item) => item.type === "Progressing");
+  const replicas = replicaSummary(row);
+  const countersSettled =
+    row.desired !== undefined && row.ready !== undefined && row.ready === row.desired
+    && (row.updated === undefined || row.updated === row.desired);
+  if (condition) {
+    if (condition.status === "False") {
+      return {
+        state: "stuck",
+        message: [condition.reason || "Progressing=False", replicas].filter(Boolean).join(" · "),
+      };
+    }
+    if (condition.status === "True" && /NewReplicaSetAvailable/i.test(condition.reason)) {
+      return { state: "complete", message: [condition.reason, replicas].filter(Boolean).join(" · ") };
+    }
+    if (countersSettled) {
+      return { state: "complete", message: replicas || "Rolled out" };
+    }
+    return {
+      state: "progressing",
+      message: [condition.reason || "Rolling out", replicas].filter(Boolean).join(" · "),
+    };
+  }
+  // No usable Progressing condition (DaemonSets, pending first status):
+  // the replica counters alone tell progress from completion.
+  if (row.desired === undefined || row.ready === undefined) return undefined;
+  if (row.ready < row.desired) {
+    return { state: "progressing", message: replicaSummary(row) || "Rolling out" };
+  }
+  if (row.updated !== undefined && row.updated < row.desired) {
+    return { state: "progressing", message: replicaSummary(row) || "Rolling out" };
+  }
+  return { state: "complete", message: replicaSummary(row) || "Ready" };
+}
+
+function replicaSummary(row: Pick<ResourceRow, "desired" | "ready" | "updated">): string {
+  if (row.desired === undefined || row.ready === undefined) return "";
+  const parts = [`${row.ready}/${row.desired} ready`];
+  if (row.updated !== undefined) parts.push(`${row.updated} updated`);
+  return parts.join(" · ");
+}
+
 function parseConditions(value: unknown): WorkloadCondition[] {
   if (!Array.isArray(value)) return [];
   return value.filter(isRecord).map((condition) => ({
diff --git a/apps/desktop/src/renderer/hooks/useDiagnostics.ts b/apps/desktop/src/renderer/hooks/useDiagnostics.ts
index 29a6a6c..21294e7 100644
--- a/apps/desktop/src/renderer/hooks/useDiagnostics.ts
+++ b/apps/desktop/src/renderer/hooks/useDiagnostics.ts
@@ -6,6 +6,8 @@ import type {
   ResourceRow,
 } from "../../shared/types";
 import { desktop } from "../lib/desktop";
+import { SLOW_POLL_MS } from "../lib/poll-cadence";
+import { isRolloutWorkloadKind } from "../detail/workload-detail";
 
 export interface DiagnosticsOptions {
   contextId: string;
@@ -22,10 +24,17 @@ export interface DiagnosticsState {
  * Owns the diagnostic surface for the selected resource: recent events and
  * owner/child relationship queries. Pod logs live in the self-contained
  * LogViewer component, not here.
+ *
+ * Events re-fetch when the selection's resourceVersion bumps (the detail's
+ * single-object watch adopts those) and, for rollout workloads only (#39),
+ * on a slow interval as a backstop for child events that do not touch the
+ * object itself — so rollout events land without a manual refresh. Other
+ * kinds keep the one-shot fetch the selection change already drives.
  */
 export function useDiagnostics({ contextId, kind, selected }: DiagnosticsOptions): DiagnosticsState {
   const [events, setEvents] = useState<ResourceEvent[]>([]);
   const [related, setRelated] = useState<RelatedResource[]>([]);
+  const liveEvents = isRolloutWorkloadKind(kind.kind);
 
   useEffect(() => {
     if (!selected || !contextId || !selected.namespace) {
@@ -33,11 +42,18 @@ export function useDiagnostics({ contextId, kind, selected }: DiagnosticsOptions
       return;
     }
     let active = true;
-    void desktop.resources.events({ contextId, resourceKind: kind, namespace: selected.namespace, name: selected.name })
-      .then((items) => active && setEvents(items))
-      .catch(() => active && setEvents([]));
-    return () => { active = false; };
-  }, [contextId, kind, selected]);
+    const load = () => {
+      void desktop.resources.events({ contextId, resourceKind: kind, namespace: selected.namespace, name: selected.name })
+        .then((items) => active && setEvents(items))
+        .catch(() => active && setEvents([]));
+    };
+    load();
+    const timer = liveEvents ? setInterval(load, SLOW_POLL_MS) : undefined;
+    return () => {
+      active = false;
+      if (timer) clearInterval(timer);
+    };
+  }, [contextId, kind, selected, liveEvents]);
 
   useEffect(() => {
     if (!selected || !contextId) {
diff --git a/apps/desktop/src/renderer/hooks/useHelm.ts b/apps/desktop/src/renderer/hooks/useHelm.ts
index 67b75c5..b926aa0 100644
--- a/apps/desktop/src/renderer/hooks/useHelm.ts
+++ b/apps/desktop/src/renderer/hooks/useHelm.ts
@@ -1,11 +1,18 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import type { HelmReleaseDetail, HelmReleaseSummary, HelmUpgradeRequest } from "../../shared/types";
+import type { HelmReleaseDetail, HelmReleaseSummary, HelmUpgradeRequest, NamespaceScope } from "../../shared/types";
 import { toast } from "@/components/ui/toast";
 import { desktop } from "../lib/desktop";
+import { namespaceScopeKey } from "../lib/namespace-scope";
 
 export interface UseHelmOptions {
   contextId: string;
-  namespace: string;
+  /**
+   * Ordered namespace selection: [] lists across all namespaces (the wire's
+   * empty namespace), one name is the ordinary single-namespace stream, and
+   * two or more fan out as one single-namespace stream per namespace merged
+   * in selection order.
+   */
+  namespaceScope: NamespaceScope;
   coreReady: boolean;
 }
 
@@ -41,7 +48,16 @@ export interface HelmState {
  * operations; the core runs them synchronously, so the view blocks on one
  * action at a time and refreshes the list when it finishes.
  */
-export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): HelmState {
+export function useHelm({ contextId, namespaceScope, coreReady }: UseHelmOptions): HelmState {
+  const scopeKey = namespaceScopeKey(namespaceScope);
+  // Row-scoped surfaces (select/upgrade/rollback) always act on a release that
+  // carries its own namespace; the primary selection is only the fallback.
+  const primaryNamespace = namespaceScope[0] ?? "";
+  // Read through the ref inside the list effect: it keys on the canonical
+  // scope key, so an upstream array re-creation with equal contents cannot
+  // tear the streams down.
+  const scopeRef = useRef(namespaceScope);
+  scopeRef.current = namespaceScope;
   const [releases, setReleases] = useState<HelmReleaseSummary[]>([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
@@ -57,12 +73,12 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
   const [progress, setProgress] = useState("");
 
   // Same scope-reset contract as useResourceDetail: when the list scope
-  // (context or namespace) changes, close any open release detail so a stale
-  // cross-namespace read can't linger under a picker that says otherwise.
+  // (context or namespace scope) changes, close any open release detail so a
+  // stale cross-namespace read can't linger under a picker that says otherwise.
   useEffect(() => {
     setSelected(undefined);
     setDetailError("");
-  }, [contextId, namespace]);
+  }, [contextId, scopeKey]);
 
   useEffect(() => {
     setReleases([]);
@@ -72,57 +88,97 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
     setLoadingMore(false);
     setLoading(Boolean(contextId && coreReady));
     if (!contextId || !coreReady) return;
+    // "" keeps its wire meaning of all namespaces, so the scope maps to one
+    // ordinary list request per entry: a single entry (one namespace or All)
+    // is just the one-entry case of the same per-namespace stream fan-out —
+    // one code path, no special cases.
+    const namespaces = scopeRef.current.length ? scopeRef.current : [""];
     let active = true;
-    let pending = false;
-    let pageRequest = 0;
-    let cursor = "";
-    let retainedCursor = "";
-    let stop = () => {};
-    const close = (continueToken: string) => {
+    let loadingPages = 0;
+    let loadingMorePages = 0;
+    const pageRequests: Record<string, number> = {};
+    const stops: Array<() => void> = [];
+    const retainedCursors: Record<string, string> = {};
+    let pages: Record<string, { releases: HelmReleaseSummary[]; cursor: string }> = {};
+    const commit = () => {
+      const merged: HelmReleaseSummary[] = [];
+      let more = false;
+      for (const namespace of namespaces) {
+        const page = pages[namespace];
+        if (!page) continue;
+        merged.push(...page.releases);
+        if (page.cursor) more = true;
+      }
+      setReleases(merged);
+      setHasMore(more);
+    };
+    const close = (namespace: string, continueToken: string) => {
       void desktop.helm.closeList({ contextId, namespace, continueToken }).catch(() => {});
     };
-    const startPage = (continueToken: string) => {
-      if (!active || pending) return;
-      pending = true;
-      const current = ++pageRequest;
-      setLoading(!continueToken);
-      setLoadingMore(Boolean(continueToken));
+    const startPage = (namespace: string, continueToken: string) => {
+      if (!active) return;
+      pageRequests[namespace] = (pageRequests[namespace] ?? 0) + 1;
+      const current = pageRequests[namespace];
+      if (continueToken) loadingMorePages += 1; else loadingPages += 1;
+      if (!continueToken) setLoading(true); else setLoadingMore(true);
       setError("");
       setProgress("");
-      stop = desktop.helm.list({ contextId, namespace, continueToken: continueToken || undefined }, (event) => {
-        if (!active || current !== pageRequest) {
-          if (!active && event.kind === "done" && event.continueToken) close(event.continueToken);
+      const stop = desktop.helm.list({ contextId, namespace, continueToken: continueToken || undefined }, (event) => {
+        if (!active || current !== pageRequests[namespace]) {
+          if (!active && event.kind === "done" && event.continueToken) close(namespace, event.continueToken);
           return;
         }
         if (event.kind === "progress") return;
-        pending = false;
-        setLoading(false);
-        setLoadingMore(false);
-        if (event.kind === "error") { setError(event.message); return; }
-        // Commit the whole page once; heartbeat/progress never changes rows.
-        setReleases((items) => continueToken ? [...items, ...(event.releases ?? [])] : (event.releases ?? []));
-        cursor = event.continueToken ?? "";
-        if (cursor) retainedCursor = cursor;
-        setHasMore(Boolean(cursor));
+        if (continueToken) loadingMorePages -= 1; else loadingPages -= 1;
+        setLoading(loadingPages > 0);
+        setLoadingMore(loadingMorePages > 0);
+        if (event.kind === "error") {
+          // Keep the loaded rows and the cursor: the namespace contributes
+          // nothing new while the others still render, and the footer's
+          // load-more retries the same page.
+          setError(event.message);
+          return;
+        }
+        // The first page replaces; a load-more page appends after the ones
+        // already loaded, exactly like the table's appendNamespacePage.
+        pages[namespace] = {
+          releases: continueToken
+            ? [...(pages[namespace]?.releases ?? []), ...(event.releases ?? [])]
+            : (event.releases ?? []),
+          cursor: event.continueToken ?? "",
+        };
+        // Retain the last non-empty token per namespace, even after a page
+        // completes: the leaving view (scope change or refresh) must still
+        // release the server-side session that token pinned — matching the
+        // single-namespace stream's close-on-leave contract.
+        if (event.continueToken) retainedCursors[namespace] = event.continueToken;
+        commit();
       });
+      stops.push(stop);
+    };
+    loadNextPage.current = () => {
+      for (const namespace of namespaces) {
+        const cursor = pages[namespace]?.cursor;
+        if (cursor) startPage(namespace, cursor);
+      }
     };
-    loadNextPage.current = () => { if (cursor) startPage(cursor); };
     stopList.current = () => {
-      ++pageRequest;
-      pending = false;
-      stop();
+      for (const namespace of namespaces) pageRequests[namespace] = (pageRequests[namespace] ?? 0) + 1;
+      stops.forEach((stop) => stop());
+      loadingPages = 0;
+      loadingMorePages = 0;
       setLoading(false);
       setLoadingMore(false);
       setProgress("Loading cancelled");
     };
-    startPage("");
+    for (const namespace of namespaces) startPage(namespace, "");
     return () => {
       active = false;
-      ++pageRequest;
-      stop();
-      if (retainedCursor) close(retainedCursor);
+      for (const namespace of namespaces) pageRequests[namespace] = (pageRequests[namespace] ?? 0) + 1;
+      stops.forEach((stop) => stop());
+      for (const [namespace, cursor] of Object.entries(retainedCursors)) close(namespace, cursor);
     };
-  }, [contextId, namespace, coreReady, generation]);
+  }, [contextId, scopeKey, coreReady, generation]);
 
   const loadMore = useCallback(() => loadNextPage.current(), []);
   const cancel = useCallback(() => stopList.current(), []);
@@ -130,7 +186,7 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
   const refresh = useCallback(() => setGeneration((value) => value + 1), []);
 
   const select = useCallback(async (name: string, releaseNamespace?: string) => {
-    const ns = releaseNamespace || namespace;
+    const ns = releaseNamespace || primaryNamespace;
     if (!contextId || !ns || !name) return;
     setDetailLoading(true);
     setDetailError("");
@@ -142,7 +198,7 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
     } finally {
       setDetailLoading(false);
     }
-  }, [contextId, namespace]);
+  }, [contextId, primaryNamespace]);
 
   const clear = useCallback(() => {
     setSelected(undefined);
@@ -150,7 +206,7 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
   }, []);
 
   const uninstall = useCallback(async (name: string) => {
-    const ns = selected?.namespace || namespace;
+    const ns = selected?.namespace || primaryNamespace;
     if (!contextId || !ns || busy) return;
     setBusy(true);
     setDetailError("");
@@ -164,10 +220,10 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
     } finally {
       setBusy(false);
     }
-  }, [contextId, namespace, selected, busy, refresh]);
+  }, [contextId, primaryNamespace, selected, busy, refresh]);
 
   const rollback = useCallback(async (name: string, revision?: number) => {
-    const ns = selected?.namespace || namespace;
+    const ns = selected?.namespace || primaryNamespace;
     if (!contextId || !ns || busy) return;
     setBusy(true);
     setDetailError("");
@@ -180,10 +236,10 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
     } finally {
       setBusy(false);
     }
-  }, [contextId, namespace, selected, busy, refresh]);
+  }, [contextId, primaryNamespace, selected, busy, refresh]);
 
   const upgrade = useCallback(async (input: HelmUpgradeInput): Promise<string | null> => {
-    const ns = selected?.namespace || namespace;
+    const ns = selected?.namespace || primaryNamespace;
     if (!contextId || !ns || busy) return "Another operation is already in progress";
     setBusy(true);
     setDetailError("");
@@ -202,7 +258,7 @@ export function useHelm({ contextId, namespace, coreReady }: UseHelmOptions): He
     } finally {
       setBusy(false);
     }
-  }, [contextId, namespace, selected, busy, select, refresh]);
+  }, [contextId, primaryNamespace, selected, busy, select, refresh]);
 
   return {
     releases,
diff --git a/apps/desktop/src/renderer/hooks/useNamespaces.ts b/apps/desktop/src/renderer/hooks/useNamespaces.ts
index bdb0071..8e30854 100644
--- a/apps/desktop/src/renderer/hooks/useNamespaces.ts
+++ b/apps/desktop/src/renderer/hooks/useNamespaces.ts
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import type { ContextInfo, NamespaceInfo } from "../../shared/types";
+import type { ContextInfo, NamespaceInfo, NamespaceScope } from "../../shared/types";
 import { messageOf } from "../lib/format";
 import { desktop } from "../lib/desktop";
 import {
@@ -16,8 +16,9 @@ export interface NamespacesState {
   loading: boolean;
   /** True after the lazy inventory has completed successfully, including empty results. */
   loaded: boolean;
-  namespace: string;
-  setNamespace(namespace: string): void;
+  /** Ordered namespace selection; [] is the All-namespaces scope. */
+  namespaceScope: NamespaceScope;
+  setNamespaceScope(scope: NamespaceScope): void;
   /** Lazily fetches the namespace list on first use (pickers, ⌘K). */
   load(): void;
 }
@@ -44,7 +45,7 @@ export function useNamespaces(
   const [namespaces, setNamespaces] = useState<NamespaceInfo[]>([]);
   const [truncated, setTruncated] = useState(false);
   const [loading, setLoading] = useState(false);
-  const [namespace, setNamespace] = useState("");
+  const [namespaceScope, setNamespaceScope] = useState<NamespaceScope>([]);
   const [loaded, setLoaded] = useState(false);
   const loadingRef = useRef(false);
   // Bumped on every context change so a slow fetch started under the previous
@@ -87,12 +88,17 @@ export function useNamespaces(
     setLoading(false);
     setLoaded(false);
     if (!contextId) {
-      setNamespace("");
+      setNamespaceScope((current) => (current.length ? [] : current));
       return;
     }
-    // The context's default namespace is known without the list.
+    // The context's default namespace is known without the list. connectContext
+    // may already have applied the same scope: bail out on equal contents so
+    // the array identity — and with it every scope-keyed effect — stays put.
     const context = contexts.find((item) => item.id === contextId);
-    setNamespace(context?.namespace || "");
+    const defaultNamespace = context?.namespace || "";
+    setNamespaceScope((current) => (
+      current.length === (defaultNamespace ? 1 : 0) && current[0] === defaultNamespace ? current : defaultNamespace ? [defaultNamespace] : []
+    ));
     // A retained list renders at once; a stale one refreshes in the background.
     const cached = readNamespaceCache(contextId);
     if (cached) {
@@ -118,5 +124,5 @@ export function useNamespaces(
     fetchList(true);
   }, [contextId, fetchList]);
 
-  return { namespaces, truncated, loading, loaded, namespace, setNamespace, load };
+  return { namespaces, truncated, loading, loaded, namespaceScope, setNamespaceScope, load };
 }
diff --git a/apps/desktop/src/renderer/hooks/usePodEvents.ts b/apps/desktop/src/renderer/hooks/usePodEvents.ts
new file mode 100644
index 0000000..3601e57
--- /dev/null
+++ b/apps/desktop/src/renderer/hooks/usePodEvents.ts
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { useEffect, useRef, useState } from "react";
+import type { ResourceEvent, ResourceKind, ResourceRow } from "../../shared/types";
+import { desktop } from "../lib/desktop";
+import { SLOW_POLL_MS } from "../lib/poll-cadence";
+import { newestEventsFirst } from "../lib/resource-events";
+
+/** Matches the events one-shot's bound; the poll never loads more than this. */
+const EVENT_LIMIT = 100;
+
+const EVENTS_KIND: ResourceKind = {
+  id: "events",
+  group: "",
+  version: "v1",
+  resource: "events",
+  kind: "Event",
+  namespaced: true,
+  category: "cluster",
+};
+
+/** Event rows carry their projection fields alongside the base row shape. */
+type EventRow = ResourceRow & { reason?: string; message?: string; type?: string };
+
+export interface PodEventsOptions {
+  contextId: string;
+  namespace: string;
+  /** The workload's current pods; events are joined client-side on these names. */
+  names: string[];
+  enabled: boolean;
+}
+
+/**
+ * Surfaces the rollout's child pod events (Pulling / Created / Started /
+ * Killing) for an open workload detail. One ordinary namespaced list request
+ * per poll — the events kind filtered server-side to pod events, joined
+ * client-side to the workload's own pod names — never a watch stream and
+ * never a per-pod fan-out. A poll finds nothing without a Metrics-Server-like
+ * error path: events are best-effort and an empty result renders as none.
+ */
+export function usePodEvents({ contextId, namespace, names, enabled }: PodEventsOptions): ResourceEvent[] {
+  const [events, setEvents] = useState<ResourceEvent[]>([]);
+  // The name set rides a ref: each poll joins against whatever the pods list
+  // currently holds, so a live pod list refreshing cannot restart the poll.
+  // Only the empty↔non-empty transition is a dependency (nothing to join
+  // against means nothing to poll for).
+  const namesRef = useRef(names);
+  namesRef.current = names;
+  const hasNames = names.length > 0;
+
+  useEffect(() => {
+    if (!enabled || !contextId || !namespace || !hasNames) {
+      setEvents([]);
+      return;
+    }
+    let active = true;
+    const load = () => {
+      void desktop.resources.list({
+        contextId,
+        resourceKind: EVENTS_KIND,
+        namespace,
+        fieldSelector: "involvedObject.kind=Pod",
+        limit: EVENT_LIMIT,
+      }).then((response) => {
+        if (!active) return;
+        const current = new Set(namesRef.current);
+        const seen = new Set<string>();
+        const joined: ResourceEvent[] = [];
+        for (const row of response.items as EventRow[]) {
+          const pod = row.involvedObject || "";
+          if (!pod || !current.has(pod)) continue;
+          if (seen.has(row.uid)) continue;
+          seen.add(row.uid);
+          joined.push({
+            name: pod,
+            namespace: row.namespace,
+            reason: row.reason,
+            message: row.message,
+            type: row.type,
+            count: row.count,
+            lastTimestamp: row.lastTimestamp,
+          });
+        }
+        setEvents(newestEventsFirst(joined, EVENT_LIMIT));
+      }).catch(() => {
+        if (active) setEvents([]);
+      });
+    };
+    load();
+    const timer = setInterval(load, SLOW_POLL_MS);
+    return () => {
+      active = false;
+      clearInterval(timer);
+    };
+  }, [contextId, namespace, hasNames, enabled]);
+
+  return events;
+}
diff --git a/apps/desktop/src/renderer/hooks/useResourceDetail.ts b/apps/desktop/src/renderer/hooks/useResourceDetail.ts
index bd74f43..ed206f6 100644
--- a/apps/desktop/src/renderer/hooks/useResourceDetail.ts
+++ b/apps/desktop/src/renderer/hooks/useResourceDetail.ts
@@ -1,15 +1,25 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import type { ResourceGetResponse, ResourceKind, ResourceRow } from "../../shared/types";
+import type { ResourceGetResponse, ResourceKind, ResourceRow, ResourceWatchBatch } from "../../shared/types";
 import { messageOf } from "../lib/format";
 import { desktop } from "../lib/desktop";
 
 export interface ResourceDetailOptions {
   contextId: string;
   kind: ResourceKind;
-  namespace: string;
+  /** Canonical key of the list's namespace scope; changes close the selection. */
+  scopeKey: string;
   /** Changes whenever the list scope resets; closes any open selection. */
   generation: number;
   items: ResourceRow[];
+  /** False keeps the live channel idle: no watch, one-shot behavior. */
+  coreReady: boolean;
+  /**
+   * True while the open object is a rollout workload, the only kind the live
+   * channel serves (#39): a single-object watch keyed on the object's
+   * identity. Other kinds keep the pre-existing behavior — the list watch
+   * bumps the selection — so no watch ever leaves with an empty namespace.
+   */
+  live: boolean;
 }
 
 export interface ResourceDetailState {
@@ -30,7 +40,11 @@ export interface ResourceDetailState {
 
 /** Identity tag of the object a fetched detail belongs to. */
 function objectTag(row: ResourceRow): string {
-  return `${row.uid || `${row.kind}:${row.namespace}/${row.name}`}@${row.resourceVersion}`;
+  return `${objectIdentity(row)}@${row.resourceVersion}`;
+}
+
+function objectIdentity(row: ResourceRow): string {
+  return row.uid || `${row.kind}:${row.namespace}/${row.name}`;
 }
 
 /**
@@ -47,8 +61,16 @@ function isNewerResourceVersion(candidate: string, current: string): boolean {
  * Owns the selected row and its fetched detail. The selection follows list
  * updates (resourceVersion bumps) and closes when the row disappears or the
  * list scope resets.
+ *
+ * While a rollout workload is open it also owns that object's live channel: a
+ * single-object watch (fieldSelector metadata.name) — lazy, one stream, closed
+ * on leave — so the vitals, conditions and YAML converge during a rollout even
+ * when the underlying list is a snapshot-only scope (All namespaces) whose
+ * watch would otherwise never bump the selection. A delta bumping the object's
+ * resourceVersion re-gets the object once, which refreshes the YAML the same
+ * way an explicit refresh does.
  */
-export function useResourceDetail({ contextId, kind, namespace, generation, items }: ResourceDetailOptions): ResourceDetailState {
+export function useResourceDetail({ contextId, kind, scopeKey, generation, items, coreReady, live }: ResourceDetailOptions): ResourceDetailState {
   const [selected, setSelected] = useState<ResourceRow>();
   const [detail, setDetail] = useState<ResourceGetResponse>();
   const [detailError, setDetailError] = useState("");
@@ -66,7 +88,7 @@ export function useResourceDetail({ contextId, kind, namespace, generation, item
     setDetail(undefined);
     setDetailError("");
     setRefreshing(false);
-  }, [contextId, kind, namespace, generation]);
+  }, [contextId, kind, scopeKey, generation]);
 
   useEffect(() => {
     if (!selected) return;
@@ -114,6 +136,58 @@ export function useResourceDetail({ contextId, kind, namespace, generation, item
     void fetchDetail(selected);
   }, [contextId, kind, selected, fetchDetail]);
 
+  // The live channel keys on the object's identity, never on the selected row
+  // itself: a resourceVersion bump adopts the row without tearing the watch
+  // subscription down and restarting it.
+  const selectedIdentity = selected ? objectIdentity(selected) : "";
+  useEffect(() => {
+    const target = selectedRef.current;
+    if (!target || !contextId || !coreReady || !live) return;
+    let active = true;
+    const adopt = (rows: ResourceRow[]) => {
+      const current = selectedRef.current;
+      if (!active || !current || objectIdentity(current) !== objectIdentity(target)) return;
+      const next = rows.find((row) => objectIdentity(row) === objectIdentity(target)
+        && isNewerResourceVersion(row.resourceVersion, current.resourceVersion));
+      if (!next) return;
+      setSelected(next);
+      // Re-get so the YAML and conditions converge with the vitals; the
+      // request guard inside fetchDetail drops stale reads.
+      void fetchDetail(next);
+    };
+    const stop = desktop.resources.watch({
+      contextId,
+      resourceKind: kind,
+      namespace: target.namespace,
+      fieldSelector: `metadata.name=${target.name}`,
+      limit: 100,
+    }, (batch: ResourceWatchBatch) => {
+      if (batch.kind === "snapshot") {
+        adopt(batch.items);
+        return;
+      }
+      if (batch.kind === "delta") {
+        for (const event of batch.events) {
+          if (event.type === "deleted") {
+            // The open object vanished (deleted out from under the view):
+            // close the detail, exactly like the list-follow path does.
+            if (event.key === objectIdentity(target)) {
+              detailFor.current = "";
+              setSelected(undefined);
+              setDetail(undefined);
+            }
+            continue;
+          }
+          adopt([event.row]);
+        }
+      }
+    });
+    return () => {
+      active = false;
+      stop();
+    };
+  }, [contextId, kind, coreReady, live, selectedIdentity, fetchDetail]);
+
   const select = useCallback((row: ResourceRow) => setSelected(row), []);
   const clear = useCallback(() => {
     detailFor.current = "";
diff --git a/apps/desktop/src/renderer/hooks/useResourceList.ts b/apps/desktop/src/renderer/hooks/useResourceList.ts
index fd109db..6fbdbdd 100644
--- a/apps/desktop/src/renderer/hooks/useResourceList.ts
+++ b/apps/desktop/src/renderer/hooks/useResourceList.ts
@@ -1,14 +1,20 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { ResourceKind, ResourceListResponse, ResourceRow, ResourceWatchBatch } from "../../shared/types";
+import type { NamespaceScope, ResourceKind, ResourceListResponse, ResourceRow, ResourceWatchBatch } from "../../shared/types";
 import { applyResourceWatchBatches } from "../lib/resource-watch";
 import { readResourceListSnapshot, resourceListCacheKey, writeResourceListSnapshot, clearResourceListSnapshots } from "../lib/resource-list-cache";
+import { MULTI_SCOPE_CONTINUE, mergeNamespacePages, namespaceScopeKey } from "../lib/namespace-scope";
 import { messageOf } from "../lib/format";
 import { desktop } from "../lib/desktop";
 
 export interface ResourceListOptions {
   contextId: string;
   kind: ResourceKind;
-  namespace: string;
+  /**
+   * Ordered namespace selection: [] is the cluster-wide All-namespaces scope,
+   * one name is the live-watch scope, two or more fan out as per-namespace
+   * snapshot requests merged in selection order.
+   */
+  namespaceScope: NamespaceScope;
   coreReady: boolean;
   setError(message: string): void;
   /** Server-side selector pinning the list, e.g. a workload's pod selector. */
@@ -36,13 +42,16 @@ export interface ResourceListState {
 }
 
 /**
- * A cluster-wide list (namespace unset on a namespaced kind) is never watched.
- * Watching it would open one cluster-scoped watch stream whose per-object
- * deltas flood the IPC channel and the API server in a 100k-namespace cluster,
- * so the table gets the first snapshot page and manual refresh only.
+ * A cluster-wide list (All-namespaces scope on a namespaced kind) is never
+ * watched. Watching it would open one cluster-scoped watch stream whose
+ * per-object deltas flood the IPC channel and the API server in a 100k-
+ * namespace cluster, so the table gets the first snapshot page and manual
+ * refresh only. A multi-namespace selection is a bounded fan-out of ordinary
+ * single-namespace snapshot requests — also never watched, so the invariant
+ * "at most one watch per list view" survives.
  */
-function watchEnabled(kind: ResourceKind, namespace: string, enabled: boolean): boolean {
-  return enabled && (kind.namespaced ? namespace !== "" : true);
+function liveWatchEnabled(kind: ResourceKind, scopeSize: number, enabled: boolean): boolean {
+  return enabled && (kind.namespaced ? scopeSize === 1 : true);
 }
 
 /**
@@ -51,7 +60,7 @@ function watchEnabled(kind: ResourceKind, namespace: string, enabled: boolean):
  * the filter query, and the visible error. Selection resets triggered by
  * list scope changes live in useResourceDetail via `generation`.
  */
-export function useResourceList({ contextId, kind, namespace, coreReady, setError, labelSelector, enabled = true }: ResourceListOptions): ResourceListState {
+export function useResourceList({ contextId, kind, namespaceScope, coreReady, setError, labelSelector, enabled = true }: ResourceListOptions): ResourceListState {
   const [list, setList] = useState<ResourceListResponse>({ items: [] });
   const [loading, setLoading] = useState(false);
   const [loadingMore, setLoadingMore] = useState(false);
@@ -73,14 +82,86 @@ export function useResourceList({ contextId, kind, namespace, coreReady, setErro
     }
     listRef.current = list;
   }, [contextId, list]);
-  const liveWatch = watchEnabled(kind, namespace, enabled);
+
+  // Multi-scope fan-out state: one snapshot page per selected namespace,
+  // merged in selection order. The ref backs loadMore; the scope ref keeps
+  // effects keyed on the order-insensitive scope key from re-running (and
+  // re-fetching everything) on a mere reordering.
+  const [multiPages, setMultiPages] = useState<Record<string, ResourceListResponse>>({});
+  const multiPagesRef = useRef(multiPages);
+  const scopeRef = useRef(namespaceScope);
+  scopeRef.current = namespaceScope;
+  multiPagesRef.current = multiPages;
+
+  const liveWatch = liveWatchEnabled(kind, namespaceScope.length, enabled);
+  // Cluster-scoped kinds ignore the scope entirely — their requests carry no
+  // namespace, so a stale multi selection must not fan out for them.
+  const multiScope = kind.namespaced && namespaceScope.length > 1;
+  const scopeKey = useMemo(() => namespaceScopeKey(namespaceScope), [namespaceScope]);
+
+  // The multi-scope view derives from the per-namespace pages in selection
+  // order; the sentinel token only signals "some namespace has another page"
+  // and is never sent back to the core.
+  const merged = useMemo(
+    () => mergeNamespacePages(namespaceScope, multiScope ? multiPages : {}),
+    [namespaceScope, multiScope, multiPages],
+  );
+  const listView: ResourceListResponse = multiScope
+    ? { items: merged.items, ...(merged.hasMore ? { continueToken: MULTI_SCOPE_CONTINUE } : {}) }
+    : list;
+  useEffect(() => {
+    listRef.current = listView;
+  }, [listView]);
 
   const loadMore = useCallback(async () => {
-    if (!contextId || !coreReady || !enabled || !list.continueToken) return;
+    if (!contextId || !coreReady || !enabled) return;
+    if (multiScope) {
+      const pages = multiPagesRef.current;
+      const pending = scopeRef.current.filter((namespace) => pages[namespace]?.continueToken);
+      if (!pending.length) return;
+      const request = ++listRequest.current;
+      setLoadingMore(true);
+      setError("");
+      let next = pages;
+      await Promise.all(pending.map(async (namespace) => {
+        try {
+          const response = await desktop.resources.list({
+            contextId,
+            resourceKind: kind,
+            namespace,
+            ...(labelSelector ? { labelSelector } : {}),
+            limit: 100,
+            continueToken: pages[namespace].continueToken,
+          });
+          if (request !== listRequest.current) return;
+          next = {
+            ...next,
+            [namespace]: {
+              ...response,
+              items: [...(next[namespace]?.items ?? []), ...response.items],
+            },
+          };
+        } catch {
+          // Keep that namespace's loaded page and token; the footer button
+          // retries only the namespaces that still have one.
+        }
+      }));
+      if (request !== listRequest.current) {
+        setLoading(false);
+        setLoadingMore(false);
+        return;
+      }
+      multiPagesRef.current = next;
+      setMultiPages(next);
+      setLoadingMore(false);
+      return;
+    }
+    if (!list.continueToken) return;
     const request = ++listRequest.current;
     setLoadingMore(true);
     setError("");
     try {
+      const namespace = scopeRef.current[0] ?? "";
       const response = await desktop.resources.list({
         contextId,
         resourceKind: kind,
@@ -99,18 +180,23 @@ export function useResourceList({ contextId, kind, namespace, coreReady, setErro
         setLoadingMore(false);
       }
     }
-  }, [contextId, coreReady, enabled, kind, labelSelector, list.continueToken, namespace, setError]);
+  }, [contextId, coreReady, enabled, kind, labelSelector, list.continueToken, multiScope, setError]);
 
   useEffect(() => {
     if (!contextId || !coreReady || !enabled) return;
+    if (multiScope) return; // handled by the fan-out effect below
     ++listRequest.current;
     setError("");
     watchQueue.current = [];
     watchHasSnapshot.current = false;
+    // Read through the ref: the effect keys on the canonical scope key, so a
+    // reordering (or an upstream array re-creation with equal contents)
+    // cannot tear the subscription down.
+    const namespace = scopeRef.current[0] ?? "";
 
     // Only watched (namespace-scoped) views retain snapshots; cluster-wide
     // snapshot-only scopes keep their manual-refresh behavior untouched.
-    const cacheKey = liveWatch ? resourceListCacheKey(contextId, kind.id, namespace, labelSelector) : "";
+    const cacheKey = liveWatch ? resourceListCacheKey(contextId, kind.id, scopeKey, labelSelector) : "";
     const cached = cacheKey ? readResourceListSnapshot(cacheKey) : undefined;
     if (cached) {
       // Stale-while-revalidate: revisit renders the retained snapshot at once
@@ -124,8 +210,8 @@ export function useResourceList({ contextId, kind, namespace, coreReady, setErro
       setList({ items: [] });
     }
 
-    // Cluster-wide namespaced lists are snapshot-only (see watchEnabled): the
-    // initial page is fetched, watch never starts, and refresh re-fetches.
+    // Cluster-wide namespaced lists are snapshot-only (see liveWatchEnabled):
+    // the initial page is fetched, watch never starts, and refresh re-fetches.
     if (!liveWatch) {
       let active = true;
       desktop.resources.list({
@@ -190,23 +276,97 @@ export function useResourceList({ contextId, kind, namespace, coreReady, setErro
         writeResourceListSnapshot(cacheKey, listRef.current);
       }
     };
-  }, [contextId, namespace, kind, coreReady, enabled, labelSelector, generation, setError, liveWatch]);
+  }, [contextId, kind, coreReady, enabled, labelSelector, generation, setError, liveWatch, multiScope, scopeKey]);
+
+  // Multi-namespace fan-out: one ordinary single-namespace snapshot request
+  // per selected namespace (never a watch), merged in selection order. The
+  // request generation supersedes every in-flight page on scope change or
+  // refresh; a failed namespace degrades to "no rows from it" while the rest
+  // still render.
+  useEffect(() => {
+    if (!multiScope || !contextId || !coreReady || !enabled) return;
+    ++listRequest.current;
+    const request = listRequest.current;
+    setError("");
+    const scope = scopeRef.current;
+    const cacheKey = resourceListCacheKey(contextId, kind.id, scopeKey, labelSelector);
+    const cached = readResourceListSnapshot(cacheKey);
+    let pages: Record<string, ResourceListResponse> = {};
+    let completed = false;
+    if (cached) {
+      // Stale-while-revalidate: the retained merged view renders at once
+      // (without page tokens — they are not part of the merged snapshot)
+      // while every namespace re-fetches its fresh snapshot in place.
+      setList(cached);
+      setMultiPages({});
+      setLoading(false);
+      setRevalidating(true);
+    } else {
+      setLoading(true);
+      setRevalidating(false);
+      setList({ items: [] });
+    }
+
+    const remaining = new Set(scope);
+    const settle = () => {
+      if (remaining.size > 0 || request !== listRequest.current) return;
+      completed = true;
+      setLoading(false);
+      setRevalidating(false);
+    };
+    const fetchOne = async (namespace: string) => {
+      try {
+        const response = await desktop.resources.list({
+          contextId,
+          resourceKind: kind,
+          namespace,
+          ...(labelSelector ? { labelSelector } : {}),
+          limit: 100,
+        });
+        if (request !== listRequest.current) return;
+        pages = { ...pages, [namespace]: response };
+        setMultiPages(pages);
+        remaining.delete(namespace);
+        settle();
+      } catch (cause) {
+        if (request !== listRequest.current) return;
+        setError(messageOf(cause));
+        remaining.delete(namespace);
+        settle();
+      }
+    };
+    for (const namespace of scope) void fetchOne(namespace);
+
+    return () => {
+      if (request !== listRequest.current) return;
+      // Retain the leaving scope's merged rows for the next revisit.
+      if (completed && scope.length) {
+        const mergedSnapshot = mergeNamespacePages(scope, pages);
+        if (mergedSnapshot.items.length) {
+          writeResourceListSnapshot(cacheKey, { items: mergedSnapshot.items });
+        }
+      }
+    };
+  }, [contextId, multiScope, scopeKey, kind, coreReady, enabled, labelSelector, generation, setError]);
 
   const visibleRows = useMemo(() => {
     const needle = query.trim().toLowerCase();
-    if (!needle) return list.items;
-    return list.items.filter((item) =>
+    if (!needle) return listView.items;
+    return listView.items.filter((item) =>
       item.name.toLowerCase().includes(needle)
       || item.namespace.toLowerCase().includes(needle)
       || item.status?.toLowerCase().includes(needle),
     );
-  }, [list.items, query]);
+  }, [listView.items, query]);
 
   const refresh = useCallback(() => setGeneration((value) => value + 1), []);
-  const reset = useCallback(() => setList({ items: [] }), []);
+  const reset = useCallback(() => {
+    setList({ items: [] });
+    setMultiPages({});
+  }, []);
 
   return {
-    list,
+    list: listView,
     loading,
     loadingMore,
     revalidating,
diff --git a/apps/desktop/src/renderer/lib/namespace-scope.test.ts b/apps/desktop/src/renderer/lib/namespace-scope.test.ts
new file mode 100644
index 0000000..b8bd73b
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/namespace-scope.test.ts
@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import type { ResourceListResponse, ResourceRow } from "../../shared/types";
+import {
+  MAX_NAMESPACE_SELECTION,
+  MULTI_SCOPE_CONTINUE,
+  appendNamespacePage,
+  mergeNamespacePages,
+  namespaceScopeKey,
+  namespaceScopeSummary,
+  toggleNamespace,
+} from "./namespace-scope";
+
+describe("toggleNamespace", () => {
+  it("appends a new namespace in click order", () => {
+    expect(toggleNamespace([], "a").scope).toEqual(["a"]);
+    expect(toggleNamespace(["a"], "b").scope).toEqual(["a", "b"]);
+    expect(toggleNamespace(["a"], "b").accepted).toBe(true);
+  });
+
+  it("removes a selected namespace and keeps the remaining order", () => {
+    const result = toggleNamespace(["a", "b", "c"], "b");
+    expect(result.scope).toEqual(["a", "c"]);
+    expect(result.accepted).toBe(true);
+  });
+
+  it("removing still works at the cap", () => {
+    const full = Array.from({ length: MAX_NAMESPACE_SELECTION }, (_, i) => `ns-${i}`);
+    const result = toggleNamespace(full, "ns-5");
+    expect(result.accepted).toBe(true);
+    expect(result.scope).toHaveLength(MAX_NAMESPACE_SELECTION - 1);
+  });
+
+  it("rejects the 33rd namespace without mutating the selection", () => {
+    const full = Array.from({ length: MAX_NAMESPACE_SELECTION }, (_, i) => `ns-${i}`);
+    const result = toggleNamespace(full, "one-too-many");
+    expect(result.accepted).toBe(false);
+    expect(result.scope).toBe(full);
+  });
+});
+
+describe("namespaceScopeKey", () => {
+  it("is order-insensitive", () => {
+    expect(namespaceScopeKey(["b", "a"])).toBe(namespaceScopeKey(["a", "b"]));
+  });
+
+  it("encodes the empty scope as the All-namespaces key", () => {
+    expect(namespaceScopeKey([])).toBe("");
+  });
+
+  it("distinguishes scopes that are not permutations of each other", () => {
+    expect(namespaceScopeKey(["a"])).not.toBe(namespaceScopeKey(["a", "b"]));
+    expect(namespaceScopeKey(["a"])).toBe(namespaceScopeKey(["a"]));
+  });
+});
+
+describe("namespaceScopeSummary", () => {
+  it("empty scope summarizes to nothing (the trigger says All namespaces)", () => {
+    expect(namespaceScopeSummary([])).toBe("");
+  });
+
+  it("one name renders alone so single-selection reads exactly as before", () => {
+    expect(namespaceScopeSummary(["kube-system"])).toBe("kube-system");
+  });
+
+  it("two names join with a comma in selection order", () => {
+    expect(namespaceScopeSummary(["a", "b"])).toBe("a, b");
+  });
+
+  it("longer selections overflow into +N from three on", () => {
+    expect(namespaceScopeSummary(["a", "b", "c"])).toBe("a, b +1");
+    expect(namespaceScopeSummary(["a", "b", "c", "d"])).toBe("a, b +2");
+    expect(namespaceScopeSummary(["a", "b", "c", "d", "e", "f"])).toBe("a, b +4");
+  });
+});
+
+function page(items: string[], continueToken?: string): ResourceListResponse {
+  return {
+    items: items.map((name) => ({
+      uid: `uid-${name}`,
+      apiVersion: "v1",
+      kind: "Pod",
+      name,
+      namespace: "ns",
+      resourceVersion: "1",
+      createdAt: "2026-08-01T00:00:00Z",
+    })),
+    ...(continueToken ? { continueToken } : {}),
+  };
+}
+
+const rowsOf = (response: ResourceListResponse) => response.items.map((row: ResourceRow) => row.name);
+
+describe("mergeNamespacePages", () => {
+  it("concatenates pages in selection order, not fetch order", () => {
+    const merged = mergeNamespacePages(["a", "b"], { b: page(["b-0"]), a: page(["a-0", "a-1"]) });
+    expect(rowsOf({ items: merged.items } as ResourceListResponse)).toEqual(["a-0", "a-1", "b-0"]);
+  });
+
+  it("a missing page contributes nothing instead of stalling the merge", () => {
+    const merged = mergeNamespacePages(["a", "b", "c"], { a: page(["a-0"]), c: page(["c-0"]) });
+    expect(rowsOf({ items: merged.items } as ResourceListResponse)).toEqual(["a-0", "c-0"]);
+  });
+
+  it("hasMore is true when any selected namespace still has a page", () => {
+    expect(mergeNamespacePages(["a", "b"], { a: page(["a-0"], "tok-a"), b: page(["b-0"]) }).hasMore).toBe(true);
+    expect(mergeNamespacePages(["a", "b"], { a: page(["a-0"]), b: page(["b-0"]) }).hasMore).toBe(false);
+    expect(mergeNamespacePages(["a", "b"], {}).hasMore).toBe(false);
+  });
+
+  it("empty scope merges to nothing", () => {
+    expect(mergeNamespacePages([], { a: page(["a-0"]) })).toEqual({ items: [], hasMore: false });
+  });
+});
+
+describe("appendNamespacePage", () => {
+  it("appends the next page after the loaded ones and adopts the new token", () => {
+    const pages = { a: page(["a-0"], "tok") };
+    const next = appendNamespacePage(pages, "a", page(["a-1"], "tok-2"));
+    expect(rowsOf(next.a)).toEqual(["a-0", "a-1"]);
+    expect(next.a.continueToken).toBe("tok-2");
+    // Pure: the input record is untouched.
+    expect(rowsOf(pages.a)).toEqual(["a-0"]);
+  });
+
+  it("a failed namespace keeps its old token so load-more retries it", () => {
+    const pages = { a: page(["a-0"], "tok-a"), b: page(["b-0"], "tok-b") };
+    const next = appendNamespacePage(pages, "a", page(["a-1"]));
+    expect(next.a.continueToken).toBeUndefined();
+    expect(next.b.continueToken).toBe("tok-b");
+  });
+
+  it("the multi-scope sentinel is a truthy marker, never sent to the core", () => {
+    expect(MULTI_SCOPE_CONTINUE).toBeTruthy();
+  });
+});
diff --git a/apps/desktop/src/renderer/lib/namespace-scope.ts b/apps/desktop/src/renderer/lib/namespace-scope.ts
new file mode 100644
index 0000000..a020aad
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/namespace-scope.ts
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ResourceListResponse, ResourceRow } from "../../shared/types";
+
+/**
+ * The namespace scope of a list view: an ordered set of selected namespace
+ * names, where the empty array is the "All namespaces" cluster-wide scope.
+ * Order is the user's selection order and drives merged-row grouping; the
+ * canonical key (namespaceScopeKey) is order-insensitive and identifies the
+ * scope wherever an identity is needed (snapshot cache, reset effects).
+ * The wire format stays single-namespace: every fan-out request is an
+ * ordinary one-namespace call.
+ */
+
+/** Bounds the per-namespace fan-out: worst case 32 list + 32 metrics requests per refresh. */
+export const MAX_NAMESPACE_SELECTION = 32;
+
+/** Sentinel continue token marking "some namespace in a multi scope has another page". */
+export const MULTI_SCOPE_CONTINUE = "\u0000multi-scope";
+
+export interface NamespaceToggle {
+  scope: string[];
+  /** False when adding would exceed MAX_NAMESPACE_SELECTION; scope is unchanged. */
+  accepted: boolean;
+}
+
+/** Toggles one namespace in the selection; removing is always allowed. */
+export function toggleNamespace(scope: string[], name: string): NamespaceToggle {
+  if (scope.includes(name)) {
+    return { scope: scope.filter((item) => item !== name), accepted: true };
+  }
+  if (scope.length >= MAX_NAMESPACE_SELECTION) {
+    return { scope, accepted: false };
+  }
+  return { scope: [...scope, name], accepted: true };
+}
+
+/**
+ * Order-insensitive identity of a scope: the sorted names joined with \u001f
+ * (a character namespace names cannot contain), "" meaning All namespaces.
+ * Used for snapshot-cache keys and reset effects, where [a, b] and [b, a]
+ * are the same scope.
+ */
+export function namespaceScopeKey(scope: string[]): string {
+  return [...scope].sort().join("\u001f");
+}
+
+/**
+ * Trigger summary: "" for All, the name alone for one selection, two names
+ * joined, and a "+N" overflow from three on so long names cannot push the
+ * toolbar's search and actions out of reach.
+ */
+export function namespaceScopeSummary(scope: string[]): string {
+  if (scope.length === 0) return "";
+  if (scope.length <= 2) return scope.join(", ");
+  return `${scope.slice(0, 2).join(", ")} +${scope.length - 2}`;
+}
+
+export interface MergedNamespacePages {
+  /** Rows concatenated in selection order, one namespace after another. */
+  items: ResourceRow[];
+  /** True when any namespace still has a server page to load. */
+  hasMore: boolean;
+}
+
+/**
+ * Merges one snapshot page per selected namespace into the ordered view.
+ * Missing pages (a namespace still loading or failed) contribute nothing
+ * rather than stalling the merge.
+ */
+export function mergeNamespacePages(
+  scope: string[],
+  pages: Readonly<Record<string, ResourceListResponse | undefined>>,
+): MergedNamespacePages {
+  const items: ResourceRow[] = [];
+  let hasMore = false;
+  for (const namespace of scope) {
+    const page = pages[namespace];
+    if (!page) continue;
+    items.push(...page.items);
+    if (page.continueToken) hasMore = true;
+  }
+  return { items, hasMore };
+}
+
+/** Returns a new pages record with one namespace's next page appended. */
+export function appendNamespacePage(
+  pages: Readonly<Record<string, ResourceListResponse>>,
+  namespace: string,
+  response: ResourceListResponse,
+): Record<string, ResourceListResponse> {
+  const current = pages[namespace];
+  return {
+    ...pages,
+    [namespace]: {
+      ...response,
+      items: [...(current?.items ?? []), ...response.items],
+    },
+  };
+}
diff --git a/apps/desktop/src/renderer/lib/poll-cadence.ts b/apps/desktop/src/renderer/lib/poll-cadence.ts
new file mode 100644
index 0000000..7ca0f17
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/poll-cadence.ts
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Shared slow-poll cadence for best-effort surfaces (pod usage, events).
+ * One named clock keeps the app's background chatter in step: surfaces that
+ * fan out per namespace all fire on the same tick instead of drifting.
+ */
+export const SLOW_POLL_MS = 15_000;
diff --git a/apps/desktop/src/renderer/lib/resource-events.ts b/apps/desktop/src/renderer/lib/resource-events.ts
new file mode 100644
index 0000000..288235b
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/resource-events.ts
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ResourceEvent } from "../../shared/types";
+
+/**
+ * The shared tail of every event timeline in the app: sort newest-first by
+ * lastTimestamp, cap the timeline, and return plain rows. Both halves of the
+ * Events tab (the object's one-shot fetch and the pod-events poll) shape
+ * their output through this.
+ */
+export function newestEventsFirst(events: ResourceEvent[], limit: number): ResourceEvent[] {
+  const withKeys = events.map((event) => ({ ...event, sortKey: event.lastTimestamp || "" }));
+  withKeys.sort((a, b) => (a.sortKey < b.sortKey ? 1 : a.sortKey > b.sortKey ? -1 : 0));
+  return withKeys.slice(0, limit).map(({ sortKey: _sortKey, ...event }) => event);
+}
diff --git a/apps/desktop/src/renderer/lib/resource-favorites.test.ts b/apps/desktop/src/renderer/lib/resource-favorites.test.ts
new file mode 100644
index 0000000..e67eafa
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/resource-favorites.test.ts
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import { mostUsedKindIds, recordKindUsage, toggleFavoriteKind } from "./resource-favorites";
+
+describe("toggleFavoriteKind", () => {
+  it("appends in starring order and removes without reordering the rest", () => {
+    let favorites = toggleFavoriteKind([], "pods");
+    favorites = toggleFavoriteKind(favorites, "deployments");
+    favorites = toggleFavoriteKind(favorites, "services");
+    expect(favorites).toEqual(["pods", "deployments", "services"]);
+    expect(toggleFavoriteKind(favorites, "deployments")).toEqual(["pods", "services"]);
+  });
+
+  it("toggling twice returns to the original list", () => {
+    expect(toggleFavoriteKind(toggleFavoriteKind(["pods"], "jobs"), "jobs")).toEqual(["pods"]);
+  });
+});
+
+describe("recordKindUsage", () => {
+  it("bumps the counter without mutating the input", () => {
+    const usage = { pods: 2 };
+    expect(recordKindUsage(usage, "pods")).toEqual({ pods: 3 });
+    expect(recordKindUsage(usage, "jobs")).toEqual({ pods: 2, jobs: 1 });
+    expect(usage).toEqual({ pods: 2 });
+  });
+});
+
+describe("mostUsedKindIds", () => {
+  it("ranks by open count, best first, capped at the limit", () => {
+    const usage = { pods: 9, deployments: 5, services: 2, jobs: 1 };
+    expect(mostUsedKindIds(usage, new Set(), 3)).toEqual(["pods", "deployments", "services"]);
+  });
+
+  it("skips starred kinds and zero counts", () => {
+    const usage = { pods: 9, deployments: 5, services: 0 };
+    expect(mostUsedKindIds(usage, new Set(["pods"]), 3)).toEqual(["deployments"]);
+  });
+
+  it("breaks ties deterministically so restarts keep the order", () => {
+    const usage = { services: 2, jobs: 2 };
+    expect(mostUsedKindIds(usage, new Set(), 3)).toEqual(["jobs", "services"]);
+  });
+});
diff --git a/apps/desktop/src/renderer/lib/resource-favorites.ts b/apps/desktop/src/renderer/lib/resource-favorites.ts
new file mode 100644
index 0000000..1eba1c6
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/resource-favorites.ts
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Sidebar quick-access bookkeeping: the kinds the operator stars (Favorites)
+ * and the kinds they actually open (Most used). Both are renderer-side UI
+ * preferences persisted in localStorage like the sidebar fold prefs — no
+ * cluster data, no shell involvement.
+ */
+
+/** Toggles one kind in the starred list; order is the starring order. */
+export function toggleFavoriteKind(favorites: string[], id: string): string[] {
+  return favorites.includes(id)
+    ? favorites.filter((item) => item !== id)
+    : [...favorites, id];
+}
+
+/** Bumps one kind's open counter. */
+export function recordKindUsage(
+  usage: Record<string, number>,
+  id: string,
+): Record<string, number> {
+  return { ...usage, [id]: (usage[id] ?? 0) + 1 };
+}
+
+/**
+ * The most-opened kinds, best first, capped and with already-starred kinds
+ * filtered out (a Favorited kind needs no second entry pointing at it).
+ * Ties resolve to the lexicographically smaller id so the list is stable
+ * across restarts.
+ */
+export function mostUsedKindIds(
+  usage: Record<string, number>,
+  exclude: ReadonlySet<string>,
+  limit: number,
+): string[] {
+  return Object.entries(usage)
+    .filter(([id, count]) => count > 0 && !exclude.has(id))
+    .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
+    .slice(0, limit)
+    .map(([id]) => id);
+}
diff --git a/apps/desktop/src/renderer/shell/Sidebar.tsx b/apps/desktop/src/renderer/shell/Sidebar.tsx
index 5bed491..a81a5e4 100644
--- a/apps/desktop/src/renderer/shell/Sidebar.tsx
+++ b/apps/desktop/src/renderer/shell/Sidebar.tsx
@@ -1,9 +1,10 @@
-import { useEffect, useState, type ComponentType } from "react";
+import { useEffect, useMemo, useState, type ComponentType } from "react";
 import {
   Boxes,
   ChevronDown,
   ChevronRight,
   Gauge,
+  Star,
   type LucideProps,
 } from "lucide-react";
 import { Button } from "@/components/ui/button";
@@ -14,6 +15,7 @@ import {
 } from "@/components/ui/tooltip";
 import { cn } from "@/lib/utils";
 import { pluralize } from "../lib/format";
+import { flattenResourceGroups } from "../lib/resource-catalog";
 import type { ContextInfo, ResourceKind } from "../../shared/types";
 
 export type SidebarIcon = ComponentType<LucideProps>;
@@ -54,6 +56,11 @@ export interface SidebarProps {
   toolGroups?: SidebarToolGroup[];
   activeToolId?: string;
   onSelectTool?(id: string): void;
+  /** Kinds starred by the operator, in starring order; rendered at the top. */
+  favoriteKindIds?: string[];
+  onToggleFavoriteKind?(id: string): void;
+  /** Most-opened kinds (best first); hidden when empty. */
+  mostUsedKindIds?: string[];
 }
 
 const GROUP_COLLAPSE_STORAGE_KEY = "aster.sidebar.groupCollapsed";
@@ -87,8 +94,12 @@ export function Sidebar({
   toolGroups,
   activeToolId,
   onSelectTool,
+  favoriteKindIds,
+  onToggleFavoriteKind,
+  mostUsedKindIds,
 }: SidebarProps) {
   const [groupPrefs, setGroupPrefs] = useState<GroupCollapsePrefs>(readGroupCollapsePrefs);
+  const starred = useMemo(() => new Set(favoriteKindIds ?? []), [favoriteKindIds]);
 
   const setGroupCollapsed = (key: string, collapsedValue: boolean) => {
     setGroupPrefs((prefs) => {
@@ -117,39 +128,68 @@ export function Sidebar({
     return pref === undefined ? !defaultCollapsed(group, nested) : !pref;
   };
 
-  const renderItem = (item: SidebarResourceItem) => {
+  const renderItem = (item: SidebarResourceItem, options?: { testIdPrefix?: string; star?: boolean }) => {
     // The kind highlight only applies while the resource table is the active
     // pane; the overview and tool panes highlight their own sidebar entries.
     const active = !overviewActive && !activeToolId && activeKind.id === item.id;
     const enabled = item.enabled !== false;
     const ItemIcon = item.icon;
     const label = item.label || pluralize(item.kind);
+    const testId = `${options?.testIdPrefix ?? "resource-nav"}-${safeTestId(item.id)}`;
+    const favorited = starred.has(item.id);
+    const body = (
+      <>
+        <ItemIcon aria-hidden="true" />
+        <span className="min-w-0 flex-1 truncate text-left">{label}</span>
+      </>
+    );
 
-    return (
+    const row = (
       <Tooltip key={item.id}>
         <TooltipTrigger
           render={
             <Button
               aria-current={active ? "page" : undefined}
               className={cn("source-list-item", active && "active")}
-              data-testid={`resource-nav-${safeTestId(item.id)}`}
+              data-testid={testId}
               disabled={!enabled}
               onClick={() => onSelectKind(toResourceKind(item))}
               variant="ghost"
             />
           }
         >
-          <ItemIcon aria-hidden="true" />
-          <span className="min-w-0 flex-1 truncate text-left">{label}</span>
+          {body}
         </TooltipTrigger>
         <TooltipContent side="right">
           {enabled ? label : `${label} is unavailable`}
         </TooltipContent>
       </Tooltip>
     );
+
+    // The star is a sibling overlay, not a control inside the row button —
+    // nested interactive elements would break both the a11y tree and clicks.
+    if (!options?.star || !onToggleFavoriteKind || !enabled) return row;
+    return (
+      <div className="source-list-item-row" key={item.id}>
+        {row}
+        <button
+          aria-label={favorited ? `Remove ${label} from favorites` : `Add ${label} to favorites`}
+          aria-pressed={favorited}
+          className={cn("source-list-item-star", favorited && "starred")}
+          data-testid={`star-${safeTestId(item.id)}`}
+          onClick={(event) => {
+            event.stopPropagation();
+            onToggleFavoriteKind(item.id);
+          }}
+          type="button"
+        >
+          <Star aria-hidden="true" />
+        </button>
+      </div>
+    );
   };
 
-  const renderGroup = (group: SidebarResourceGroup, nested: boolean, parentLabel?: string) => {
+  const renderGroup = (group: SidebarResourceGroup, nested: boolean, parentLabel?: string, options?: { testIdPrefix?: string; star?: boolean }) => {
     const key = parentLabel ? `${parentLabel}/${group.label}` : group.label;
     const open = isGroupOpen(group, nested, key);
 
@@ -181,7 +221,7 @@ export function Sidebar({
         </button>
         {open ? (
           <div className="source-list-group-items grid gap-0.5">
-            {group.items.map((item) => renderItem(item))}
+            {group.items.map((item) => renderItem(item, options))}
             {(group.children ?? []).map((child) => renderGroup(child, true, group.label))}
           </div>
         ) : null}
@@ -189,6 +229,22 @@ export function Sidebar({
     );
   };
 
+  // Quick access resolves its entries against the full catalog so a starred
+  // kind renders with the same icon/label/enabled state as its home row.
+  const itemsById = useMemo(
+    () => new Map(flattenResourceGroups(resourceGroups).map((item) => [item.id, item])),
+    [resourceGroups],
+  );
+  const resolveItems = (ids: string[]) => ids
+    .map((id) => itemsById.get(id))
+    .filter((item): item is SidebarResourceItem => Boolean(item));
+  const favoriteGroup: SidebarResourceGroup | undefined = favoriteKindIds?.length
+    ? { label: "Favorites", items: resolveItems(favoriteKindIds) }
+    : undefined;
+  const mostUsedGroup: SidebarResourceGroup | undefined = mostUsedKindIds?.length
+    ? { label: "Most used", items: resolveItems(mostUsedKindIds) }
+    : undefined;
+
   return (
     <aside
       aria-label="Kubernetes source list"
@@ -249,6 +305,12 @@ export function Sidebar({
           </div>
         ) : null}
 
+        {/* Quick access: the operator's starred kinds, then the kinds this
+            cluster's usage actually opens most — both before the fixed
+            catalog so the frequent rows are always one glance away. */}
+        {favoriteGroup ? renderGroup(favoriteGroup, false, undefined, { testIdPrefix: "resource-nav-fav" }) : null}
+        {mostUsedGroup ? renderGroup(mostUsedGroup, false, undefined, { testIdPrefix: "resource-nav-most" }) : null}
+
         {toolGroups?.length ? (
           <div className="source-list-tools pb-1" data-testid="source-list-tools">
             {toolGroups.map((group) => (
@@ -286,7 +348,7 @@ export function Sidebar({
           </div>
         ) : null}
 
-        {resourceGroups.map((group) => renderGroup(group, false))}
+        {resourceGroups.map((group) => renderGroup(group, false, undefined, { star: true }))}
       </nav>
     </aside>
   );
diff --git a/apps/desktop/src/renderer/shell/UnifiedToolbar.tsx b/apps/desktop/src/renderer/shell/UnifiedToolbar.tsx
index daf30c2..2aafa55 100644
--- a/apps/desktop/src/renderer/shell/UnifiedToolbar.tsx
+++ b/apps/desktop/src/renderer/shell/UnifiedToolbar.tsx
@@ -15,6 +15,7 @@ import {
   Settings,
   Sun,
   SunMoon,
+  X,
 } from "lucide-react";
 
 import { Badge } from "@/components/ui/badge";
@@ -34,9 +35,9 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 import { cn } from "@/lib/utils";
-import type { NamespaceInfo } from "../../shared/types";
+import type { NamespaceInfo, NamespaceScope } from "../../shared/types";
 import { searchNamespaces } from "../lib/namespace-search";
-
+import { MAX_NAMESPACE_SELECTION, namespaceScopeSummary, toggleNamespace } from "../lib/namespace-scope";
 export type AppearanceTheme = "system" | "light" | "dark";
 
 export interface UnifiedToolbarProps {
@@ -49,8 +50,8 @@ export interface UnifiedToolbarProps {
   namespacesLoaded?: boolean;
   /** Called when the namespace picker opens; the list loads lazily on first use. */
   onNamespaceOpen?(): void;
-  namespace: string;
-  onNamespaceChange(namespace: string): void;
+  namespaceScope: NamespaceScope;
+  onNamespaceScopeChange(scope: NamespaceScope): void;
   namespaceDisabled?: boolean;
   query: string;
   onQueryChange(query: string): void;
@@ -69,11 +70,12 @@ export interface UnifiedToolbarProps {
 }
 
 const ALL_NAMESPACES_VALUE = "__aster_all_namespaces__";
+const ALL_NAMESPACES_ITEM: NamespaceItem = { value: ALL_NAMESPACES_VALUE, label: "All namespaces" };
 /** Cap rendered matches so a 10k-namespace cluster never mounts 10k rows. */
 const NAMESPACE_MATCH_LIMIT = 100;
 
 interface NamespaceItem {
-  value: string | null;
+  value: string;
   label: string;
 }
 
@@ -83,8 +85,8 @@ export function UnifiedToolbar({
   namespacesLoading = false,
   namespacesLoaded = false,
   onNamespaceOpen,
-  namespace,
-  onNamespaceChange,
+  namespaceScope,
+  onNamespaceScopeChange,
   namespaceDisabled = false,
   query,
   onQueryChange,
@@ -102,26 +104,54 @@ export function UnifiedToolbar({
   className,
 }: UnifiedToolbarProps) {
   const ThemeIcon = theme === "dark" ? Moon : theme === "light" ? Sun : SunMoon;
-  // A null-valued first item is the "All namespaces" choice; the label map
-  // keeps the raw value out of the trigger (Base UI renders values by default).
+  // The first item is the "All namespaces" choice under a sentinel value: in
+  // multiple mode every selected value is an array element, so the zero-
+  // selection state is expressed as the sentinel being the only member. The
+  // label map keeps raw values out of the trigger (Base UI renders values by
+  // default).
   const [namespaceQuery, setNamespaceQuery] = useState("");
   // IME composition text for the resource search. While it is non-null the
   // input displays the in-progress composition (a controlled input would
   // otherwise swallow it on the next render), but the query prop — and with it
   // the resource filter — stays on the last committed text.
   const [composingQuery, setComposingQuery] = useState<string | null>(null);
-  // The null row is offered only while the filter is empty: with a query, its
+  // The All row is offered only while the filter is empty: with a query, its
   // "All namespaces" label would collide with a real namespace (e.g. "all") in
-  // Base UI's autoHighlight and let Enter pick cluster scope by mistake, and
+  // Base UI's autoHighlight and let Enter clear the scope by mistake, and
   // during loading it would sit highlighted above the direct-Enter commit.
-  const namespaceItems = useMemo<NamespaceItem[]>(() => [
-    ...(!namespaceQuery.trim() ? [{ value: null, label: "All namespaces" }] : []),
-    ...namespaces.map((item) => ({ value: item.name as string | null, label: item.name })),
-  ], [namespaces, namespaceQuery]);
-  const selectedNamespace = namespaceItems.find((item) => item.value === (namespace || null)) ?? null;
-  // The popup is controlled so a direct-Enter commit (below) can close it even
-  // when the typed value is not a list row Base UI would auto-select.
+  // Selected namespaces follow in selection order before the unselected rest,
+  // so the rows a multi-selection act on (toggle off, review) are always at
+  // the top instead of scattered through the alphabetical list.
+  const namespaceItems = useMemo<NamespaceItem[]>(() => {
+    const byName = new Map(namespaces.map((item) => [item.name, { value: item.name, label: item.name }]));
+    const chosen: NamespaceItem[] = [];
+    for (const name of namespaceScope) {
+      const item = byName.get(name);
+      if (item) {
+        chosen.push(item);
+        byName.delete(name);
+      }
+    }
+    return [
+      ...(!namespaceQuery.trim() ? [ALL_NAMESPACES_ITEM] : []),
+      ...chosen,
+      ...byName.values(),
+    ];
+  }, [namespaces, namespaceQuery, namespaceScope]);
+  // Selection values are rebuilt from the scope (selected names need not be
+  // list rows — a direct-Enter commit can add one before the inventory loads),
+  // so item identity is bridged with isItemEqualToValue.
+  const namespaceValue = useMemo<NamespaceItem[]>(() => (
+    namespaceScope.length
+      ? namespaceScope.map((name) => ({ value: name, label: name }))
+      : [ALL_NAMESPACES_ITEM]
+  ), [namespaceScope]);
+  // The popup is controlled so a direct-Enter commit (below) can keep it open
+  // and clear the filter on its own terms.
   const [namespaceOpen, setNamespaceOpen] = useState(false);
+  // Set when a toggle or commit is rejected at the selection cap; the footer
+  // slot explains it until the next successful change or close.
+  const [capReached, setCapReached] = useState(false);
   // Progressive narrowing: a short prefix on a huge cluster matches tens of
   // thousands of names — rendering 100 of them is noise. The hint shows the
   // exact match count instead, and concrete rows appear as the user types.
@@ -129,21 +159,47 @@ export function UnifiedToolbar({
     const names = namespaces.map((item) => item.name);
     return searchNamespaces(names, namespaceQuery);
   }, [namespaces, namespaceQuery]);
-  const namespaceFooter = namespaceSearch.narrowed
-    ? `${namespaceSearch.total.toLocaleString()} namespaces match — keep typing to narrow`
-    : null;
+
+  // Toggling rows applies immediately (no "Done" step). Base UI reports the
+  // post-toggle array; the sentinel's intent — "clear the whole selection" —
+  // is read from it being newly added, since the zero-selection state keeps
+  // the sentinel selected and any later toggle would carry it along.
+  const handleScopeChange = (next: NamespaceItem[]) => {
+    const names = next
+      .filter((item) => item.value !== ALL_NAMESPACES_VALUE)
+      .map((item) => item.value);
+    const allAdded = namespaceScope.length > 0 && next.some((item) => item.value === ALL_NAMESPACES_VALUE);
+    if (allAdded) {
+      setCapReached(false);
+      onNamespaceScopeChange([]);
+      return;
+    }
+    if (names.length > MAX_NAMESPACE_SELECTION) {
+      setCapReached(true);
+      return;
+    }
+    setCapReached(false);
+    onNamespaceScopeChange(names);
+  };
 
   // Direct-Enter: the user knows the exact namespace (e.g. "ns-abcdefg") and
   // should not wait for the whole inventory to load. kubernetes/dashboard's
   // selector does the same: Enter commits the raw input value without a list
   // hit. It only fires when no concrete row is selectable (list loading or
   // zero matches) — with rows on screen, Enter belongs to Base UI's
-  // autoHighlight, which selects the highlighted row instead.
+  // autoHighlight, which toggles the highlighted row instead. In multiple
+  // mode the commit toggles the name into the selection and stays open.
   const commitNamespaceInput = () => {
     const value = namespaceQuery.trim();
     if (!value) return;
-    onNamespaceChange(value);
-    setNamespaceOpen(false);
+    const result = toggleNamespace(namespaceScope, value);
+    if (!result.accepted) {
+      setCapReached(true);
+      return;
+    }
+    setCapReached(false);
+    onNamespaceScopeChange(result.scope);
+    setNamespaceQuery("");
   };
 
   return (
@@ -175,9 +231,12 @@ export function UnifiedToolbar({
 
       <div className="toolbar-namespace">
         <Combobox.Root
+          multiple
           autoHighlight
           disabled={namespaceDisabled}
           items={namespaceItems}
+          isItemEqualToValue={(item, value) => item.value === value.value}
+          inputValue={namespaceQuery}
           limit={NAMESPACE_MATCH_LIMIT}
           // IME-safe: Base UI's input holds composition text back and only
           // fires this for committed text (it calls setInputValue at
@@ -187,22 +246,29 @@ export function UnifiedToolbar({
           onOpenChange={(open) => {
             setNamespaceOpen(open);
             if (open) onNamespaceOpen?.();
-            if (!open) setNamespaceQuery("");
+            if (!open) {
+              setNamespaceQuery("");
+              setCapReached(false);
+            }
           }}
-          onValueChange={(item) => onNamespaceChange(item?.value ?? "")}
+          onValueChange={(value) => handleScopeChange(value)}
           open={namespaceOpen}
-          value={selectedNamespace}
+          value={namespaceValue}
         >
           <Combobox.Trigger
             aria-label="Namespace"
             className="namespace-select"
             data-testid="namespace-select"
           >
-            <span className="namespace-select-value">
-              {/* Rendered from the hook state, not Combobox.Value: a direct-Enter
-                  commit can select a namespace that is not a list item, and
-                  Combobox.Value would fall back to the placeholder for it. */}
-              {namespace || "All namespaces"}
+            <span
+              className="namespace-select-value"
+              title={namespaceScope.length > 2 ? namespaceScope.join(", ") : undefined}
+            >
+              {/* Rendered from the hook state, not Combobox.Value: direct-Enter
+                  commits and cap rejections can select namespaces that are not
+                  list items, and Combobox.Value would fall back to the
+                  placeholder for them. */}
+              {namespaceScopeSummary(namespaceScope) || "All namespaces"}
             </span>
             <Combobox.Icon className="namespace-select-icon">
               <ChevronsUpDown aria-hidden="true" />
@@ -219,7 +285,7 @@ export function UnifiedToolbar({
                     onKeyDown={(event) => {
                       if (event.key !== "Enter") return;
                       // Yield to Base UI whenever a concrete row is selectable:
-                      // with autoHighlight, Enter must select the highlighted
+                      // with autoHighlight, Enter must toggle the highlighted
                       // row (e.g. "kube-system" for the prefix "kube-s"), not
                       // commit the raw prefix.
                       if (namespaceSearch.shown.length > 0) return;
@@ -232,11 +298,11 @@ export function UnifiedToolbar({
                       // Empty filter with no rows: the list is still loading
                       // (or the cluster has no namespaces) and the rendered
                       // "All namespaces" row is the only selectable scope, so
-                      // commit the null scope directly instead of leaning on
+                      // clear the selection directly instead of leaning on
                       // Base UI's autoHighlight, which is unreliable while the
                       // selection is not in the still-loading items.
                       if (!namespaceQuery.trim()) {
-                        onNamespaceChange("");
+                        onNamespaceScopeChange([]);
                         setNamespaceOpen(false);
                         return;
                       }
@@ -259,15 +325,23 @@ export function UnifiedToolbar({
                 )}
                 <Combobox.List className="namespace-combobox-list">
                   {(item: NamespaceItem) => {
-                    if (item.value === null) return renderNamespaceItem(item, ALL_NAMESPACES_VALUE);
                     // Only rows that survive the prefix search are rendered;
                     // the narrowed hint below covers the rest.
-                    if (!namespaceSearch.shown.includes(item.label)) return null;
-                    return renderNamespaceItem(item, item.value as string);
+                    if (item.value !== ALL_NAMESPACES_VALUE && !namespaceSearch.shown.includes(item.label)) return null;
+                    const selected = item.value === ALL_NAMESPACES_VALUE
+                      ? namespaceScope.length === 0
+                      : namespaceScope.includes(item.value);
+                    return renderNamespaceItem(item, selected);
                   }}
                 </Combobox.List>
-                {namespaceSearch.narrowed ? (
-                  <div className="namespace-combobox-footer">{namespaceFooter}</div>
+                {capReached ? (
+                  <div className="namespace-combobox-footer" data-testid="namespace-cap-message">
+                    Up to {MAX_NAMESPACE_SELECTION} namespaces selected
+                  </div>
+                ) : namespaceSearch.narrowed ? (
+                  <div className="namespace-combobox-footer">
+                    {namespaceSearch.total.toLocaleString()} namespaces match — keep typing to narrow
+                  </div>
                 ) : namespacesTruncated ? (
                   <div className="namespace-combobox-footer">
                     First {namespaces.length.toLocaleString()} namespaces — type to narrow (large cluster)
@@ -277,6 +351,25 @@ export function UnifiedToolbar({
             </Combobox.Positioner>
           </Combobox.Portal>
         </Combobox.Root>
+        {/* One-click way out of a multi selection (the picker's All row is
+            the two-click one): only for 2+ names — a single namespace is the
+            ordinary scope, not a selection to undo. */}
+        {namespaceScope.length > 1 ? (
+          <Button
+            aria-label="Clear namespace selection"
+            className="namespace-clear"
+            data-testid="namespace-clear"
+            onClick={() => {
+              setNamespaceOpen(false);
+              setCapReached(false);
+              onNamespaceScopeChange([]);
+            }}
+            size="icon"
+            variant="ghost"
+          >
+            <X aria-hidden="true" />
+          </Button>
+        ) : null}
       </div>
 
       <label className="toolbar-search">
@@ -369,12 +462,13 @@ export function UnifiedToolbar({
   );
 }
 
-function renderNamespaceItem(item: NamespaceItem, key: string) {
+function renderNamespaceItem(item: NamespaceItem, selected: boolean) {
   return (
     <Combobox.Item
-      key={key}
+      key={item.value}
       value={item}
       className="namespace-combobox-item"
+      data-selected={selected || undefined}
     >
       <span className="namespace-combobox-check">
         <Combobox.ItemIndicator>
diff --git a/apps/desktop/src/renderer/styles.css b/apps/desktop/src/renderer/styles.css
index 8278f20..b3f33e8 100644
--- a/apps/desktop/src/renderer/styles.css
+++ b/apps/desktop/src/renderer/styles.css
@@ -1156,7 +1156,25 @@ h2 {
 }
 
 .toolbar-namespace {
+  display: flex;
   min-width: 0;
+  align-items: center;
+  gap: 2px;
+}
+
+/* One-click exit from a multi namespace selection; visually part of the
+   picker chip, functionally its own control. */
+.namespace-clear {
+  width: 20px;
+  height: 20px;
+  flex-shrink: 0;
+  border-radius: 5px;
+  color: var(--muted-foreground);
+}
+
+.namespace-clear svg {
+  width: 13px;
+  height: 13px;
 }
 
 .toolbar-actions {
@@ -1310,6 +1328,13 @@ h2 {
   user-select: none;
 }
 
+/* Selected rows read at a glance and stay reachable at the top of the list;
+   the same tokens as the table's row checkbox, per the picker spec. */
+.namespace-combobox-item[data-selected] {
+  color: var(--text);
+  background: var(--surface-hover);
+}
+
 .namespace-combobox-item[data-highlighted] {
   color: var(--text);
   background: var(--selection);
@@ -1317,14 +1342,80 @@ h2 {
 
 .namespace-combobox-check {
   display: flex;
-  width: 12px;
-  height: 12px;
+  width: 14px;
+  height: 14px;
   flex-shrink: 0;
   align-items: center;
-  color: var(--focus);
+  justify-content: center;
+  border: 1px solid var(--border-strong);
+  border-radius: 4px;
+  color: var(--primary-foreground);
+  background: transparent;
+}
+
+.namespace-combobox-item[data-selected] .namespace-combobox-check {
+  border-color: var(--focus);
+  background: var(--focus);
 }
 
 .namespace-combobox-check svg {
+  width: 11px;
+  height: 11px;
+}
+
+/* Sidebar favorite star: hidden until the row is hovered, persistent (and
+   filled) once starred. A sibling overlay of the row button, so the a11y
+   tree keeps the two controls separate. */
+.source-list-item-row {
+  position: relative;
+}
+
+.source-list-item-row .source-list-item {
+  padding-right: 22px;
+}
+
+.source-list-item-star {
+  position: absolute;
+  top: 50%;
+  right: 4px;
+  display: flex;
+  width: 18px;
+  height: 18px;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: 0;
+  border-radius: 4px;
+  color: var(--muted-foreground);
+  background: transparent;
+  cursor: pointer;
+  opacity: 0;
+  transform: translateY(-50%);
+  transition: opacity 100ms ease, color 100ms ease, background-color 100ms ease;
+}
+
+.source-list-item-row:hover .source-list-item-star,
+.source-list-item-star:focus-visible,
+.source-list-item-star.starred {
+  opacity: 1;
+}
+
+.source-list-item-star:hover {
+  color: var(--text);
+  background: var(--surface-hover);
+}
+
+.source-list-item-star.starred {
+  /* Interactive blue, not amber: the semantic colors stay reserved for
+     operational status (DESIGN.md), and a star is a user choice. */
+  color: var(--focus);
+}
+
+.source-list-item-star.starred svg {
+  fill: currentColor;
+}
+
+.source-list-item-star svg {
   width: 12px;
   height: 12px;
 }
diff --git a/apps/desktop/src/renderer/views/HelmView.tsx b/apps/desktop/src/renderer/views/HelmView.tsx
index b17db51..cbb8a1a 100644
--- a/apps/desktop/src/renderer/views/HelmView.tsx
+++ b/apps/desktop/src/renderer/views/HelmView.tsx
@@ -9,7 +9,8 @@ import { HelmUpgradeDialog } from "./HelmUpgradeDialog";
 
 export interface HelmViewProps {
   contextName?: string;
-  namespace: string;
+  /** Human summary of the namespace scope, e.g. "default, kube-system +1". */
+  scopeLabel: string;
   releases: HelmReleaseSummary[];
   loading: boolean;
   error: string;
@@ -46,7 +47,7 @@ function statusTone(status: string): string {
 
 export function HelmView({
   contextName,
-  namespace,
+  scopeLabel,
   releases,
   loading,
   error,
@@ -71,7 +72,7 @@ export function HelmView({
         <div className="pane-heading">
           <div>
             <h1>Releases</h1>
-            <p>Helm · {contextName ? `${contextName} · ` : ""}{namespace}</p>
+            <p>Helm · {contextName ? `${contextName} · ` : ""}{scopeLabel}</p>
           </div>
           <div className="resource-summary">
             <span>{releases.length} loaded</span>
@@ -104,7 +105,7 @@ export function HelmView({
           onLoadMore={onLoadMore}
           loading={loading}
           error={error}
-          namespace={namespace}
+          scopeLabel={scopeLabel}
           onSelect={onSelect}
         />
       )}
@@ -119,7 +120,7 @@ function ReleaseTable({
   onLoadMore,
   loading,
   error,
-  namespace,
+  scopeLabel,
   onSelect,
 }: {
   releases: HelmReleaseSummary[];
@@ -128,7 +129,7 @@ function ReleaseTable({
   onLoadMore(): void;
   loading: boolean;
   error: string;
-  namespace: string;
+  scopeLabel: string;
   onSelect(name: string, namespace: string): void;
 }) {
   const viewport = useRef<HTMLDivElement>(null);
@@ -159,7 +160,7 @@ function ReleaseTable({
   if (releases.length === 0) {
     return (
       <div className="table-state" data-testid="helm-empty">
-        <span>No releases in {namespace}</span>
+        <span>No releases in {scopeLabel}</span>
       </div>
     );
   }
diff --git a/apps/desktop/src/shared/types.ts b/apps/desktop/src/shared/types.ts
index b74ec90..8b75334 100644
--- a/apps/desktop/src/shared/types.ts
+++ b/apps/desktop/src/shared/types.ts
@@ -108,6 +108,14 @@ export interface NamespaceInfo {
   message?: string;
 }
 
+/**
+ * The list scope carried by renderer state: an ordered selection of namespace
+ * names where the empty array is the "All namespaces" cluster-wide scope.
+ * Renderer-only — the wire format stays single-namespace; a multi selection
+ * fans out as ordinary one-namespace requests.
+ */
+export type NamespaceScope = string[];
+
 /**
  * A hard cap keeps a 100k-namespace cluster from streaming its whole
  * inventory into the renderer. `truncated` is explicit so pickers can
@@ -148,6 +156,8 @@ export interface ResourceRow {
   dataKeys?: string[];
   count?: number;
   lastTimestamp?: string;
+  /** For Event rows: the name of the object the event is about. */
+  involvedObject?: string;
   related?: string[];
 }
 
diff --git a/apps/desktop/tests/renderer-smoke.spec.ts b/apps/desktop/tests/renderer-smoke.spec.ts
index 13ad8e2..3592373 100644
--- a/apps/desktop/tests/renderer-smoke.spec.ts
+++ b/apps/desktop/tests/renderer-smoke.spec.ts
@@ -225,6 +225,8 @@ const MOCK_DESKTOP_API = `
     },
     metrics: {
       pods: async (_contextId, namespace) => {
+        // Recorded so the multi-namespace fan-out tests can count calls.
+        (window.__metricsRequests = window.__metricsRequests || []).push(namespace || "");
         // One container per pod, values oscillate so the detail chart shows a
         // line, and the pod detail the test opens (pods-0) reports usage.
         const value = (base, index) => base + (index % 3) * 5;
@@ -253,6 +255,8 @@ const MOCK_DESKTOP_API = `
     },
     helm: {
       list: ({ namespace }, listener) => {
+        // Recorded so the multi-namespace fan-out tests can count streams.
+        (window.__helmRequests = window.__helmRequests || []).push(namespace || "");
         const releases = [
         // An empty namespace means all namespaces; surface releases from
         // distinct namespaces so the All-namespaces list is distinguishable.
@@ -297,7 +301,11 @@ const MOCK_DESKTOP_API = `
       },
     },
     resources: {
-      list: async (request) => pageOf(request),
+      list: async (request) => {
+        // Recorded so the multi-namespace fan-out tests can count requests.
+        (window.__resourceRequests = window.__resourceRequests || []).push({ kind: "list", namespace: request.namespace || "" });
+        return pageOf(request);
+      },
       get: async (request) => {
         // The list may open any row, not just index 0; derive the index from
         // the requested name so the returned uid matches the selected row.
@@ -383,6 +391,7 @@ const MOCK_DESKTOP_API = `
         return { operation: request.operation, dryRun: Boolean(request.dryRun), changed: true, resourceVersion: "1001", name: request.name, yaml };
       },
       watch: (request, listener) => {
+        (window.__resourceRequests = window.__resourceRequests || []).push({ kind: "watch", namespace: request.namespace || "" });
         const timer = setTimeout(() => {
           listener({
             subscriptionId: "fixture-watch",
@@ -736,6 +745,153 @@ test("resource detail opens and preserves layout", async ({ page }) => {
   expect(failures).toEqual([]);
 });
 
+test("deployment detail stays live during a rollout without manual refresh", async ({ page }) => {
+  // In the all-namespaces snapshot scope the table never bumps the selection,
+  // so the detail must keep itself live: one single-object watch (fieldSelector
+  // metadata.name) adopts resourceVersion bumps and re-gets the object so the
+  // vitals, conditions and YAML converge — and closing the detail stops it.
+  await page.addInitScript(() => {
+    const desktop = (window as unknown as {
+      __ASTER_DESKTOP__?: {
+        resources: {
+          watch(request: unknown, listener: (batch: unknown) => void): () => void;
+          list(request: unknown): Promise<unknown>;
+          get(request: unknown): Promise<{ row: Record<string, unknown>; yaml: string }>;
+          events(request: unknown): Promise<unknown[]>;
+        };
+      };
+    }).__ASTER_DESKTOP__;
+    if (!desktop) return;
+    const detailRow = (over: Record<string, unknown>) => ({
+      uid: "deployments-uid-0",
+      apiVersion: "apps/v1",
+      kind: "Deployment",
+      name: "deployments-0",
+      namespace: "default",
+      resourceVersion: "1000",
+      createdAt: "2026-08-01T00:00:00Z",
+      status: "Running",
+      desired: 2,
+      ready: 2,
+      available: 2,
+      updated: 2,
+      images: ["nginx:1.27"],
+      ...over,
+    });
+    const watches: Array<{ listener: (batch: unknown) => void; cancelled: boolean }> = [];
+    (window as unknown as { __detailWatches: typeof watches }).__detailWatches = watches;
+    const baseWatch = desktop.resources.watch.bind(desktop.resources);
+    desktop.resources.watch = (request, listener) => {
+      const fieldSelector = String((request as { fieldSelector?: string }).fieldSelector || "");
+      if (!fieldSelector.startsWith("metadata.name=")) return baseWatch(request, listener);
+      const session = { listener, cancelled: false };
+      watches.push(session);
+      setTimeout(() => session.listener({
+        subscriptionId: "detail-watch",
+        kind: "snapshot",
+        items: [detailRow({})],
+      }), 0);
+      return () => { session.cancelled = true; };
+    };
+    // Once the rollout is driven, the live get reports the new generation.
+    const baseGet = desktop.resources.get.bind(desktop.resources);
+    desktop.resources.get = async (request) => {
+      const response = await baseGet(request);
+      if (!(window as unknown as { __rolloutStarted?: boolean }).__rolloutStarted) return response;
+      const yaml = response.yaml.replace(
+        /    - type: Progressing[\s\S]*?lastTransitionTime: "[^"]*"/,
+        [
+          "    - type: Progressing",
+          '      status: "True"',
+          "      reason: ReplicaSetUpdated",
+          '      message: ReplicaSet "deployments-0-7d9" is progressing.',
+          '      lastTransitionTime: "2026-09-15T00:00:05Z"',
+        ].join("\n"),
+      );
+      return {
+        row: detailRow({ resourceVersion: "1002", status: "Progressing", desired: 5, ready: 2, available: 2, updated: 2 }),
+        yaml: yaml.replace("  replicas: 2", "  replicas: 5"),
+      };
+    };
+    // The pod-events poll: one pod event joined to the workload's own pod.
+    const podEvent = {
+      uid: "ev-pull", apiVersion: "v1", kind: "Event", name: "pull.17ab", namespace: "default",
+      resourceVersion: "1", createdAt: "2026-09-15T00:00:01Z", involvedObject: "pods-0",
+      reason: "Pulling", message: "Pulling image nginx:1.28", type: "Normal", count: 1,
+      lastTimestamp: "2026-09-15T00:00:01Z",
+    };
+    (window as unknown as { __podEvents: unknown[] }).__podEvents = [podEvent];
+    const baseList = desktop.resources.list.bind(desktop.resources);
+    desktop.resources.list = async (request) => {
+      if (String((request as { fieldSelector?: string }).fieldSelector || "").startsWith("involvedObject.kind=Pod")) {
+        return { items: (window as unknown as { __podEvents: unknown[] }).__podEvents };
+      }
+      return baseList(request);
+    };
+    // The object's own events grow once the rollout starts.
+    (window as unknown as { __rolloutEvents: unknown[] }).__rolloutEvents = [];
+    desktop.resources.events = async () => {
+      const base = [{ name: "event-1", namespace: "default", reason: "Scheduled", message: "Successfully assigned", type: "Normal", count: 1, lastTimestamp: "2026-08-01T00:00:00Z" }];
+      return [...base, ...((window as unknown as { __rolloutEvents: unknown[] }).__rolloutEvents as unknown[])];
+    };
+    (window as unknown as { __driveRollout: () => void }).__driveRollout = () => {
+      (window as unknown as { __rolloutStarted?: boolean }).__rolloutStarted = true;
+      (window as unknown as { __rolloutEvents: unknown[] }).__rolloutEvents = [
+        { name: "event-2", namespace: "default", reason: "ScalingReplicaSet", message: "Scaled up replica set deployments-0-7d9 from 2 to 5", type: "Normal", count: 1, lastTimestamp: "2026-09-15T00:00:04Z" },
+      ];
+      const session = watches.at(-1);
+      session?.listener({
+        subscriptionId: "detail-watch",
+        kind: "delta",
+        events: [{ type: "modified", row: detailRow({ resourceVersion: "1002", status: "Progressing", desired: 5, ready: 2, available: 2, updated: 2 }) }],
+      });
+    };
+  });
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  // All-namespaces scope: the table is a snapshot and never bumps the selection.
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "All namespaces" }).click();
+  await page.keyboard.press("Escape");
+
+  const grid = page.getByRole("grid", { name: "Resources" });
+  const firstRow = grid.getByRole("row").nth(1);
+  await expect(firstRow).toContainText("deployments-0", { timeout: 15_000 });
+  await firstRow.click();
+  const detail = page.getByTestId("resource-detail-view");
+  await expect(detail).toBeVisible({ timeout: 15_000 });
+
+  // Baseline: the rollout chip reads the live YAML's Progressing condition.
+  await expect(page.getByTestId("rollout-status")).toContainText("Rolled out");
+  await expect(page.getByTestId("overview-pods")).toContainText("pods-0", { timeout: 15_000 });
+  // The pod event joined from the poll shows up beside the object's own.
+  await expect(detail.getByTestId("overview-events")).toContainText("Pulling image nginx:1.28", { timeout: 15_000 });
+
+  // Drive the rollout: a watch delta (rv 1002) plus a get that reports the
+  // new generation. Nothing here touches refresh.
+  await page.evaluate(() => (window as unknown as { __driveRollout: () => void }).__driveRollout());
+
+  // Vitals converge: ready 2 of the new desired 5.
+  const vitals = page.getByTestId("resource-vitals");
+  await expect(vitals).toContainText("2/5", { timeout: 15_000 });
+  // The chip flips to in-progress and the live condition replaces the old one.
+  await expect(page.getByTestId("rollout-status")).toContainText("Rollout in progress");
+  await expect(page.getByTestId("resource-conditions")).toContainText("ReplicaSetUpdated", { timeout: 15_000 });
+  // The object's fresh ScalingReplicaSet event landed without a refresh.
+  await expect(detail.getByTestId("overview-events")).toContainText("Scaled up replica set", { timeout: 15_000 });
+  await expectNoOverflow(page, "detail mid-rollout 1280x800");
+  await screenshot(page, "detail-rollout-live-1280");
+
+  // Leaving the detail tears the single-object watch down.
+  await page.keyboard.press("Escape");
+  await expect(detail).toHaveCount(0);
+  await expect.poll(() => page.evaluate(() => (window as unknown as { __detailWatches: Array<{ cancelled: boolean }> }).__detailWatches.at(-1)?.cancelled)).toBe(true);
+  expect(failures).toEqual([]);
+});
+
 test("YAML editor scrolls long lines horizontally instead of wrapping", async ({ page }) => {
   const failures = collectFailures(page);
   await page.setViewportSize({ width: 1280, height: 800 });
@@ -1722,7 +1878,13 @@ test("helm loads atomic pages of 50 on demand and cancels stale scopes", async (
   await expect(page.getByText("stale failure")).toHaveCount(0);
   await page.getByTestId("namespace-select").click();
   await page.locator(".namespace-combobox-item", { hasText: "kube-system" }).click();
-  expect(await page.evaluate(() => (window as any).__helmSessions.at(-2).cancelled)).toBe(true);
+  // Multi-select applies immediately and keeps the popup open: the scope is
+  // now default + kube-system, the previous single-scope stream was
+  // cancelled, and one stream per selected namespace replaced it.
+  await page.keyboard.press("Escape");
+  expect(await page.evaluate(() => (window as any).__helmSessions[4].cancelled)).toBe(true);
+  expect(await page.evaluate(() => (window as any).__helmSessions.at(-2).request.namespace)).toBe("default");
+  expect(await page.evaluate(() => (window as any).__helmSessions.at(-1).request.namespace)).toBe("kube-system");
   await page.getByTestId("helm-cancel").click();
   expect(await page.evaluate(() => (window as any).__helmSessions.at(-1).cancelled)).toBe(true);
   await page.getByTestId("helm-refresh").click();
@@ -1936,21 +2098,22 @@ test("namespace picker commits a typed namespace with Enter before the list load
   await connectToDev(page);
 
   // Open the picker, type a namespace that is not in the (still loading) list,
-  // and press Enter: the picker switches scope without waiting.
+  // and press Enter: the name toggles into the selection without waiting —
+  // appended next to the context default, not replacing it.
   await page.getByTestId("namespace-select").click();
   const filter = page.getByTestId("namespace-filter");
   await expect(filter).toBeVisible();
   await filter.fill("ns-abcdefg");
   await page.keyboard.press("Enter");
-  await expect(page.getByTestId("namespace-select")).toContainText("ns-abcdefg");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, ns-abcdefg");
   await screenshot(page, "namespace-enter-commit");
   expect(failures).toEqual([]);
 });
 
 test("namespace picker Enter selects the highlighted row when matches exist", async ({ page }) => {
   // Direct-Enter must not hijack Base UI's autoHighlight: typing a prefix of
-  // a loaded namespace and pressing Enter selects the highlighted row, not
-  // the raw prefix.
+  // a loaded namespace and pressing Enter toggles the highlighted row into
+  // the selection, not the raw prefix.
   const failures = collectFailures(page);
   await page.setViewportSize({ width: 1280, height: 800 });
   await page.goto("/");
@@ -1961,7 +2124,7 @@ test("namespace picker Enter selects the highlighted row when matches exist", as
   await filter.fill("kube");
   await expect(page.locator(".namespace-combobox-item", { hasText: "kube-system" })).toBeVisible();
   await page.keyboard.press("Enter");
-  await expect(page.getByTestId("namespace-select")).toContainText("kube-system");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, kube-system");
   await screenshot(page, "namespace-enter-highlighted-row");
   expect(failures).toEqual([]);
 });
@@ -2091,10 +2254,12 @@ test("namespace picker Enter respects the All-namespaces row while loading", asy
   await expect(page.getByTestId("namespace-loading")).toBeVisible();
 
   // Non-empty filter while loading: the null row is gone, nothing is
-  // highlighted, so direct-Enter commits the raw input.
+  // highlighted, so direct-Enter appends the raw input to the selection.
   await filter.fill("all");
   await page.keyboard.press("Enter");
-  await expect(page.getByTestId("namespace-select")).toHaveText("all");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, all");
+  // Toggling never closes the popup on its own; close it before reopening.
+  await page.keyboard.press("Escape");
   await expect(filter).toBeHidden();
 
   // Reopen with an empty filter while the fetch is still in flight: the
@@ -2144,7 +2309,7 @@ test("namespace picker Enter prefers a real namespace named all over cluster sco
   await expect(rows.filter({ hasText: /^all$/ })).toBeVisible();
   await expect(rows.filter({ hasText: "All namespaces" })).toHaveCount(0);
   await page.keyboard.press("Enter");
-  await expect(page.getByTestId("namespace-select")).toHaveText("all");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, all");
   await screenshot(page, "namespace-enter-named-all");
   expect(failures).toEqual([]);
 });
@@ -2265,16 +2430,22 @@ test("switching back to a namespace restores the cached snapshot instantly", asy
   await expect(loadingState).toBeVisible();
   await expect(grid.getByRole("row").nth(1)).toContainText("deployments-0", { timeout: 15_000 });
 
-  // Cold first visit to kube-system: the full-pane spinner returns.
+  // Toggle to the kube-system scope: kube-system in, default out. The fresh
+  // watch for the new single-namespace scope shows the spinner again.
   await page.getByTestId("namespace-select").click();
   await namespaceItem("kube-system").click();
+  await namespaceItem("default").click();
+  await page.keyboard.press("Escape");
   await expect(loadingState).toBeVisible();
   await expect(grid.getByRole("row").nth(1)).toContainText("deployments-0", { timeout: 15_000 });
 
-  // Switching back to default is a revisit: retained rows render at once and
-  // the loading state never appears, while the heading reports the refresh.
+  // Toggling back (kube-system out, default in) is a revisit: retained rows
+  // render at once and the loading state never appears, while the heading
+  // reports the refresh.
   await page.getByTestId("namespace-select").click();
+  await namespaceItem("kube-system").click();
   await namespaceItem("default").click();
+  await page.keyboard.press("Escape");
   await expect(loadingState).toHaveCount(0);
   await expect(grid.getByRole("row").nth(1)).toContainText("deployments-0");
   const heading = page.locator(".pane-heading");
@@ -2293,6 +2464,225 @@ test("switching back to a namespace restores the cached snapshot instantly", asy
   expect(failures).toEqual([]);
 });
 
+test("namespace picker multi-selects namespaces and merges the table", async ({ page }) => {
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  const grid = page.getByRole("grid", { name: "Resources" });
+  const requests = () => page.evaluate(() => (window as unknown as { __resourceRequests?: Array<{ kind: string; namespace: string }> }).__resourceRequests ?? []);
+  const listNamespaces = async () => (await requests()).filter((request) => request.kind === "list").map((request) => request.namespace);
+  const watchNamespaces = async () => (await requests()).filter((request) => request.kind === "watch").map((request) => request.namespace);
+
+  // Baseline: the default scope is a live watch, no list requests.
+  await expect(grid.getByRole("row").nth(1)).toContainText("deployments-0", { timeout: 15_000 });
+  expect(await listNamespaces()).toEqual([]);
+
+  // A checked row is about to go stale: it must not survive the scope change.
+  await grid.getByTestId("select-row-deployments-0").click();
+  await expect(page.getByTestId("selection-count")).toContainText("1 selected");
+
+  // Toggle kube-system in: the trigger summarizes the pair and the table
+  // merges one snapshot page per namespace in selection order — with no
+  // watch stream, ever.
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "kube-system" }).click();
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, kube-system");
+  const rows = grid.getByRole("row");
+  await expect(rows.nth(1)).toContainText("deployments-0");
+  await expect(rows.nth(1)).toContainText("default");
+  // Only the visible virtualized window renders; scroll into the
+  // kube-system block to prove its rows merged after the default ones.
+  await grid.locator(".table-viewport").evaluate((element) => { element.scrollTop = 105 * 36; });
+  const kubeRow = grid.getByRole("row", { name: /Select deployments-0 .*kube-system/ });
+  await expect(kubeRow).toBeVisible();
+  await grid.locator(".table-viewport").evaluate((element) => { element.scrollTop = 0; });
+  expect(await listNamespaces()).toEqual(["default", "kube-system"]);
+  expect(await watchNamespaces()).toEqual(["default"]);
+  // The merged list says honestly that it is a manual snapshot.
+  await expect(page.locator(".pane-heading")).toContainText("2 namespaces (snapshot, refresh to update)");
+  // The stale checked row cleared with the scope.
+  await expect(page.getByTestId("selection-count")).toHaveCount(0);
+
+  // The All-namespaces row is the zero-selection state: one click clears.
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "All namespaces" }).click();
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId("namespace-select")).toHaveText("All namespaces");
+  expect(await listNamespaces()).toEqual(["default", "kube-system", ""]);
+
+  // Direct-Enter appends a namespace that is not even in the list.
+  await page.getByTestId("namespace-select").click();
+  const filter = page.getByTestId("namespace-filter");
+  await filter.fill("apps");
+  await page.keyboard.press("Enter");
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId("namespace-select")).toHaveText("apps");
+  // A single-namespace selection is a live watch again, exactly as before.
+  expect(await watchNamespaces()).toEqual(["default", "apps"]);
+
+  // Context switch resets the selection to the context's default namespace.
+  await page.getByTestId("change-context").click();
+  const prod = page.getByTestId("context-option-prod");
+  await prod.click();
+  await prod.dblclick();
+  await expect(page.getByTestId("workbench-shell")).toBeVisible();
+  await expect(page.getByTestId("namespace-select")).toHaveText("default");
+  await screenshot(page, "namespace-multiselect-merged");
+  expect(failures).toEqual([]);
+});
+
+test("multi-selection caps at 32 namespaces with a footer message", async ({ page }) => {
+  await page.addInitScript(() => {
+    const desktop = (window as unknown as {
+      __ASTER_DESKTOP__?: { namespaces: { list(contextId: string): Promise<unknown> } };
+    }).__ASTER_DESKTOP__;
+    if (desktop) {
+      desktop.namespaces.list = async () => ({
+        namespaces: Array.from({ length: 40 }, (_, index) => ({ name: `cap-${String(index).padStart(2, "0")}`, status: "Active" })),
+        truncated: false,
+      });
+    }
+  });
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "All namespaces" }).click();
+  // The All row cleared the context-default selection; now the cap counts
+  // pure additions.
+  for (let index = 0; index < 33; index++) {
+    await page.locator(".namespace-combobox-item", { hasText: `cap-${String(index).padStart(2, "0")}` }).click();
+  }
+  // The 33rd click is rejected in place: the footer explains the cap.
+  await expect(page.getByTestId("namespace-cap-message")).toContainText("Up to 32 namespaces");
+  await expect(page.getByTestId("namespace-select")).toHaveText("cap-00, cap-01 +30");
+  // Every fan-out is one request per selected namespace; the union across
+  // the test is exactly the 32 names that joined, never the rejected 33rd.
+  const namespaces = await page.evaluate(() =>
+    ((window as unknown as { __resourceRequests?: Array<{ kind: string; namespace: string }> }).__resourceRequests ?? [])
+      .filter((request) => request.kind === "list" && request.namespace.startsWith("cap-"))
+      .map((request) => request.namespace),
+  );
+  expect(new Set(namespaces).size).toBe(32);
+  expect(namespaces).not.toContain("cap-32");
+  await screenshot(page, "namespace-cap-32");
+  expect(failures).toEqual([]);
+});
+
+test("helm merges releases across a multi-namespace selection", async ({ page }) => {
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "kube-system" }).click();
+  await page.keyboard.press("Escape");
+
+  await page.getByTestId("tool-nav-helm").click();
+  const view = page.getByTestId("helm-view");
+  await expect(view).toBeVisible();
+  // One stream per selected namespace; releases render per namespace.
+  expect(await page.evaluate(() => (window as unknown as { __helmRequests?: string[] }).__helmRequests)).toEqual(["default", "kube-system"]);
+  await expect(view.getByTestId("helm-release-web")).toHaveCount(2);
+  const first = view.getByTestId("helm-release-web").first();
+  await first.click();
+  const detail = page.getByTestId("helm-detail");
+  await expect(detail).toBeVisible();
+  // Opening a merged release reads the release's own namespace.
+  await expect(detail).toContainText("default");
+  await expectNoOverflow(page, "helm multi-namespace 1280x800");
+  await screenshot(page, "helm-multiselect-1280");
+  expect(failures).toEqual([]);
+});
+
+test("pod usage covers every selected namespace", async ({ page }) => {
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "kube-system" }).click();
+  await page.keyboard.press("Escape");
+
+  await page.getByTestId("resource-nav-pods").click();
+  const grid = page.getByRole("grid", { name: "Resources" });
+  await expect(grid.getByRole("row").nth(1)).toContainText("pods-0", { timeout: 15_000 });
+  // One ordinary metrics call per selected namespace, merged by ns/name.
+  expect(await page.evaluate(() => (window as unknown as { __metricsRequests?: string[] }).__metricsRequests)).toEqual(["default", "kube-system"]);
+  // The default block's pods-0 reports 120m on screen...
+  await expect(grid.locator(".pod-usage-cell", { hasText: "120m" }).first()).toBeVisible();
+  // ...and so does the kube-system block's pods-0: same pod name, its own
+  // usage row, no trading across namespaces.
+  await grid.locator(".table-viewport").evaluate((element) => { element.scrollTop = 100 * 36; });
+  const kubePodRow = grid.getByRole("row", { name: /Select pods-0 .*kube-system/ });
+  await expect(kubePodRow).toBeVisible();
+  await expect(kubePodRow.locator(".pod-usage-cell").first()).toHaveText("120m");
+  await grid.locator(".table-viewport").evaluate((element) => { element.scrollTop = 0; });
+  await expectNoOverflow(page, "pods multi-namespace 1280x800");
+  await screenshot(page, "pods-multiselect-usage-1280");
+  expect(failures).toEqual([]);
+});
+
+test("sidebar favorites and most used surface frequent kinds", async ({ page }) => {
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  // Starring a kind pins it into the Favorites group at the top of the
+  // sidebar; the star rides the row button as a sibling control.
+  await page.getByTestId("resource-nav-pods").hover();
+  await page.getByTestId("star-pods").click();
+  await expect(page.getByTestId("resource-nav-fav-pods")).toBeVisible();
+
+  // Opening kinds feeds Most used (top three, best first); starred kinds are
+  // not duplicated there.
+  await page.getByTestId("resource-nav-services").click();
+  await page.getByTestId("resource-nav-jobs").click();
+  await expect(page.getByTestId("resource-nav-most-services")).toBeVisible();
+  await expect(page.getByTestId("resource-nav-most-jobs")).toBeVisible();
+  await expect(page.getByTestId("resource-nav-most-pods")).toHaveCount(0);
+  // The quick-access entries navigate like their home rows.
+  await page.getByTestId("resource-nav-most-services").click();
+  await expect(page.getByRole("grid", { name: "Resources" }).getByRole("row").nth(1)).toContainText("services-0", { timeout: 15_000 });
+
+  // The star persists in localStorage; unstarring removes the favorite again.
+  expect(await page.evaluate(() => localStorage.getItem("aster.sidebar.favoriteKinds"))).toContain("pods");
+  await page.getByTestId("resource-nav-pods").hover();
+  await page.getByTestId("star-pods").click();
+  await expect(page.getByTestId("resource-nav-fav-pods")).toHaveCount(0);
+  await screenshot(page, "sidebar-favorites-most-used");
+  expect(failures).toEqual([]);
+});
+
+test("a multi namespace selection clears with one click on the trigger x", async ({ page }) => {
+  const failures = collectFailures(page);
+  await page.setViewportSize({ width: 1280, height: 800 });
+  await page.goto("/");
+  await connectToDev(page);
+
+  // Single selection is the ordinary scope: no undo control.
+  await expect(page.getByTestId("namespace-clear")).toHaveCount(0);
+
+  await page.getByTestId("namespace-select").click();
+  await page.locator(".namespace-combobox-item", { hasText: "kube-system" }).click();
+  await page.keyboard.press("Escape");
+  await expect(page.getByTestId("namespace-select")).toHaveText("default, kube-system");
+  // One click back to the cluster-wide scope, no popup round-trip.
+  await page.getByTestId("namespace-clear").click();
+  await expect(page.getByTestId("namespace-select")).toHaveText("All namespaces");
+  await expect(page.getByTestId("namespace-clear")).toHaveCount(0);
+  await screenshot(page, "namespace-clear-x");
+  expect(failures).toEqual([]);
+});
+
 test("helm view lists releases across namespaces when the picker is on All namespaces", async ({ page }) => {
   const failures = collectFailures(page);
   await page.setViewportSize({ width: 1280, height: 800 });
diff --git a/core/internal/resources/projection.go b/core/internal/resources/projection.go
index d67e8d4..4fbe164 100644
--- a/core/internal/resources/projection.go
+++ b/core/internal/resources/projection.go
@@ -71,6 +71,7 @@ func project(object *unstructured.Unstructured) ResourceRow {
 	case "Namespace":
 		row.Status, _, _ = unstructured.NestedString(object.Object, "status", "phase")
 	case "Event":
+		row.InvolvedObject, _, _ = unstructured.NestedString(object.Object, "involvedObject", "name")
 		row.Reason, _, _ = unstructured.NestedString(object.Object, "reason")
 		row.Message, _, _ = unstructured.NestedString(object.Object, "message")
 		row.Type, _, _ = unstructured.NestedString(object.Object, "type")
diff --git a/core/internal/resources/types.go b/core/internal/resources/types.go
index 643f4e7..97bfb6e 100644
--- a/core/internal/resources/types.go
+++ b/core/internal/resources/types.go
@@ -257,6 +257,7 @@ type ResourceRow struct {
 	Subjects        []string          `json:"subjects,omitempty"`
 	Version         string            `json:"version,omitempty"`
 	Related         []string          `json:"related,omitempty"`
+	InvolvedObject  string            `json:"involvedObject,omitempty"`
 	Count           *int64            `json:"count,omitempty"`
 	LastTimestamp   *time.Time        `json:"lastTimestamp,omitempty"`
 }