@skyhook-io/radar-app 1.13.0 → 1.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyhook-io/radar-app",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "description": "Radar's full web UI as a reusable React component. Used by Radar's own binary and by external consumers like Radar Cloud.",
   "repository": {
     "type": "git",

package/src/App.tsx

@@ -37,6 +37,7 @@ import { CloudFunnelButton } from './components/CloudFunnelButton'
 import { useNavCustomization } from './context/NavCustomization'
 import type { FleetTakeoverTarget } from './context/NavCustomization'
 import { PrimaryNavRail } from './components/nav/PrimaryNavRail'
+import { navigateFromPrimaryRail } from './components/nav/navigation'
 import { useNavRailPinned } from './hooks/useNavRailPinned'
 import { useMediaQuery } from './hooks/useMediaQuery'
 import { ContextSwitchProvider, useContextSwitch } from './context/ContextSwitchContext'
@@ -322,7 +323,12 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
   // The AI panel is an absolute slot in the body frame (the column under the header):
   // it reserves a right gutter on the CONTENT only, so the navbar + nav rail stay
   // static. contentGutter is the docked panel width (0 when closed/overlay/maximized).
-  const { open: diagnoseOpen, contentGutter } = useDiagnoseLayout()
+  const {
+    open: diagnoseOpen,
+    close: closeDiagnose,
+    contentGutter,
+    maximized: diagnoseMaximized,
+  } = useDiagnoseLayout()
   // Hand off to a host-owned URL. The host's `onHostNavigate` (Radar Cloud's
   // cross-tree swap) navigates same-document so the chrome morphs instead of
   // cold-booting; without it we fall back to a hard `window.location` nav.
@@ -468,12 +474,19 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
 
     const path = view === 'home' ? '/' : `/${view}`
 
-    // Start fresh — keep only cross-view params (namespaces), discard all view-specific ones
+    // Start fresh — keep only cross-view params, discard view-specific ones.
+    // Read the live location because Diagnose owns `ai-run` through the History
+    // API; React Router's searchParams snapshot does not update for that write.
     const newParams = new URLSearchParams()
-    const globalNamespaces = searchParams.get('namespaces')
+    const currentParams = new URLSearchParams(window.location.search)
+    const globalNamespaces = currentParams.get('namespaces')
     if (globalNamespaces) {
       newParams.set('namespaces', globalNamespaces)
     }
+    const diagnoseRun = currentParams.get('ai-run')
+    if (diagnoseRun) {
+      newParams.set('ai-run', diagnoseRun)
+    }
 
     // Add any new params
     if (params) {
@@ -483,7 +496,18 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
     }
 
     navigate({ pathname: path, search: newParams.toString() })
-  }, [navigate, searchParams, takeover, goHost])
+  }, [navigate, takeover, goHost])
+
+  // The standalone rail expresses intent to leave the full-width investigation
+  // workspace. Close it before routing so the destination is immediately visible;
+  // docked investigations stay open across views as a persistent side panel.
+  const handlePrimaryNavigate = useCallback((view: ExtendedMainView) => {
+    navigateFromPrimaryRail(
+      diagnoseOpen && diagnoseMaximized,
+      closeDiagnose,
+      () => setMainView(view),
+    )
+  }, [diagnoseOpen, diagnoseMaximized, closeDiagnose, setMainView])
 
   // Cloud (embedded) takes over the "fleet-shaped" per-cluster views with its
   // own fleet pages scoped to this cluster — owned by the host's left rail — so
@@ -1135,9 +1159,13 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
       setSelectedResource(null)
       setSelectedHelmRelease(null)
 
-      // Reset URL to current view with no resource-specific params.
-      // Old cluster's selected pod/resource/kind don't exist on the new cluster.
-      navigate({ pathname: location.pathname, search: '' }, { replace: true })
+      // Reset resource-specific params while retaining the durable investigation
+      // focus. Diagnose resolves runs by id and owns whether the focused run is
+      // still readable after the context switch.
+      const nextParams = new URLSearchParams()
+      const diagnoseRun = new URLSearchParams(window.location.search).get('ai-run')
+      if (diagnoseRun) nextParams.set('ai-run', diagnoseRun)
+      navigate({ pathname: location.pathname, search: nextParams.toString() }, { replace: true })
 
       // Auto-unpause so the new cluster's topology loads immediately
       setTopologyPaused(false)
@@ -1658,7 +1686,7 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
       {showNavRail && (
         <PrimaryNavRail
           activeView={navActiveView}
-          onNavigate={setMainView}
+          onNavigate={handlePrimaryNavigate}
           pinned={navRailEffectivePinned}
           onTogglePinned={toggleNavRailPinned}
           showPinToggle={!railForcedSlim}

package/src/RadarApp.tsx

@@ -228,7 +228,7 @@ export function RadarApp({
                   value={renderDiagnoseAction ?? defaultDiagnoseAction}
                   consentCopy={diagnoseConsent}
                 >
-                  <DiagnoseProvider>
+                  <DiagnoseProvider browserURLState={router !== "memory"}>
                     <App
                       manageDocumentTitle={manageDocumentTitle}
                       documentTitleSuffix={documentTitleSuffix}

package/src/api/diagnose.ts

@@ -1,7 +1,7 @@
 // Client for the local AI-diagnose engine (OSS BYO-agent). The agent CLI runs
 // on the user's own machine/subscription against Radar's MCP; this just starts
 // the investigation and consumes its SSE event stream.
-import { getApiBase, getCredentialsMode } from "./config";
+import { getApiBase, getAuthHeaders, getCredentialsMode } from "./config";
 
 export interface AgentInfo {
   name: string;
@@ -81,6 +81,7 @@ export interface DiagnoseStreamEvent {
   error?: string;
   question?: string; // on "turn"
   apply?: boolean; // on "turn"
+  actor?: string; // human author on shared hosted transcripts
 }
 
 // A run is a durable, server-owned investigation. Its lifetime is independent of
@@ -101,11 +102,17 @@ export interface RunSummary {
   effort?: string;
   managedBy?: string; // GitOps/Helm owner of the target ("Argo CD"/"Flux"/"Helm"), for the Apply warning
   health?: ResourceHealthSignal;
-  status: "running" | "done" | "error" | "stopped" | "stale";
+  status: "running" | "stopping" | "done" | "error" | "stopped" | "stale";
   sessionId?: string;
   preview?: string;
   createdAt: string;
   updatedAt: string;
+  visibility?: "private" | "organization";
+  ownedByMe?: boolean;
+  canManageVisibility?: boolean;
+  canContinue?: boolean;
+  trigger?: "interactive" | "background";
+  radarUrl?: string;
 }
 
 export async function fetchAgents(
@@ -113,6 +120,7 @@ export async function fetchAgents(
 ): Promise<AgentsResponse> {
   const res = await fetch(`${getApiBase()}/agents`, {
     credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
     signal,
   });
   if (!res.ok) throw new Error(`agents: ${res.status}`);
@@ -167,7 +175,7 @@ export async function createRun(
   const res = await fetch(RUNS(), {
     method: "POST",
     credentials: getCredentialsMode(),
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...getAuthHeaders() },
     body: JSON.stringify({ ...target, ...opts }),
   });
   if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
@@ -186,6 +194,7 @@ export interface RunsResponse {
 export async function listRuns(signal?: AbortSignal): Promise<RunsResponse> {
   const res = await fetch(RUNS(), {
     credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
     signal,
   });
   if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
@@ -193,12 +202,41 @@ export async function listRuns(signal?: AbortSignal): Promise<RunsResponse> {
   return { runs: d.runs ?? [], historyDegraded: !!d.historyDegraded };
 }
 
+// getRun resolves a stable run id directly. Deep links use this rather than
+// relying on a bounded history page to happen to contain the target.
+export async function getRun(
+  id: string,
+  signal?: AbortSignal,
+): Promise<RunSummary> {
+  const res = await fetch(`${RUNS()}/${encodeURIComponent(id)}`, {
+    credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
+    signal,
+  });
+  if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
+  return res.json();
+}
+
+export async function updateRunVisibility(
+  id: string,
+  visibility: "private" | "organization",
+): Promise<RunSummary> {
+  const res = await fetch(`${RUNS()}/${encodeURIComponent(id)}`, {
+    method: "PATCH",
+    credentials: getCredentialsMode(),
+    headers: { "Content-Type": "application/json", ...getAuthHeaders() },
+    body: JSON.stringify({ visibility }),
+  });
+  if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
+  return res.json();
+}
+
 // recordConsent acknowledges the current disclosure for an execution profile, server-side.
 export async function recordConsent(surface: string): Promise<void> {
   const res = await fetch(`${getApiBase()}/diagnose/consent`, {
     method: "POST",
     credentials: getCredentialsMode(),
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...getAuthHeaders() },
     body: JSON.stringify({ surface }),
   });
   if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
@@ -210,6 +248,7 @@ export async function clearHistory(): Promise<void> {
   const res = await fetch(`${getApiBase()}/diagnose/history/clear`, {
     method: "POST",
     credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
   });
   if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
 }
@@ -222,7 +261,7 @@ export async function addTurn(
   const res = await fetch(`${RUNS()}/${id}/turns`, {
     method: "POST",
     credentials: getCredentialsMode(),
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...getAuthHeaders() },
     body: JSON.stringify(body),
   });
   if (!res.ok) throw new DiagnoseError(res.status, await errorText(res));
@@ -233,6 +272,7 @@ export async function stopRun(id: string): Promise<void> {
   await fetch(`${RUNS()}/${id}/stop`, {
     method: "POST",
     credentials: getCredentialsMode(),
+    headers: getAuthHeaders(),
   }).catch(() => {});
 }
 

package/src/components/diagnose/AISettings.tsx

@@ -49,7 +49,7 @@ function ClearHistoryRow({
     <div className="mt-3 flex items-center justify-between gap-2 border-t border-theme-border/60 pt-3">
       <p className="text-[11px] leading-snug text-theme-text-tertiary">
         {hosted ? (
-          `Investigation transcripts are stored by ${agentLabel} so history survives restarts.`
+          `${agentLabel} stores private, organization-shared, and automatic investigation transcripts so history survives restarts.`
         ) : (
           <>
             Investigation transcripts are kept on this machine (
@@ -67,6 +67,12 @@ function ClearHistoryRow({
             Couldn&apos;t clear history.
           </span>
         )}
+        {hosted && confirming && state === "idle" && (
+          <span className="ml-1 font-medium text-red-400">
+            This permanently deletes every member&apos;s investigations for this
+            cluster — private, organization-shared, and automatic.
+          </span>
+        )}
       </p>
       {confirming ? (
         <div className="flex shrink-0 items-center gap-1.5">
@@ -133,9 +139,8 @@ export function AISettingsSection({
           selectedAgent={draft.agent}
           // Model + effort are agent-specific; reset them when the agent changes.
           onSelectAgent={(a) => {
-            const nextProfile = agents.find(
-              (agent) => agent.name === a,
-            )?.profiles?.[0];
+            const nextProfile = agents.find((agent) => agent.name === a)
+              ?.profiles?.[0];
             onChange({
               agent: a,
               profile: nextProfile ?? draft.profile,

package/src/components/diagnose/DiagnoseContext.tsx

@@ -17,11 +17,13 @@ import {
 } from "react";
 import {
   fetchAgents,
+  getRun,
   listRuns,
   createRun,
   recordConsent,
   DiagnoseError,
 } from "../../api/diagnose";
+import { getApiBase } from "../../api/config";
 import {
   type RunSummary,
   type AgentInfo,
@@ -86,6 +88,7 @@ interface DiagnoseCtx {
   approveConsent: () => void;
   cancelConsent: () => void;
   refreshRuns: () => void;
+  updateRunSummary: (run: RunSummary) => void;
   dismissError: () => void;
 }
 
@@ -95,6 +98,7 @@ interface DiagnoseCtx {
 // churns the business context) doesn't re-render the whole shell.
 interface DiagnoseLayoutCtx {
   open: boolean;
+  close: () => void;
   contentGutter: number; // px right-gutter for the content area when docked (0 = overlay/closed)
   maximized: boolean;
   setMaximized: Dispatch<SetStateAction<boolean>>;
@@ -186,7 +190,58 @@ function writeStored(key: string, value: string) {
   }
 }
 
-export function DiagnoseProvider({ children }: { children: ReactNode }) {
+function runIDFromLocation(browserURLState: boolean): string | null {
+  if (!diagnoseURLStateEnabled(browserURLState)) return null;
+  try {
+    return new URLSearchParams(window.location.search).get("ai-run");
+  } catch {
+    return null;
+  }
+}
+
+function writeRunIDToLocation(
+  id: string | null,
+  push: boolean,
+  browserURLState: boolean,
+) {
+  if (!diagnoseURLStateEnabled(browserURLState)) return;
+  try {
+    const url = new URL(window.location.href);
+    if (id) url.searchParams.set("ai-run", id);
+    else url.searchParams.delete("ai-run");
+    window.history[push ? "pushState" : "replaceState"](
+      window.history.state,
+      "",
+      `${url.pathname}${url.search}${url.hash}`,
+    );
+    // History API writes do not notify BrowserRouter. Replaying the new state as
+    // popstate keeps every later navigate/setSearchParams call on the same live
+    // query string instead of letting a stale router snapshot erase ai-run.
+    window.dispatchEvent(
+      new PopStateEvent("popstate", { state: window.history.state }),
+    );
+  } catch {
+    /* URL APIs unavailable — panel state still works for this session */
+  }
+}
+
+// Fleet pages host the panel against a cluster-scoped API while remaining on a
+// hub route such as /issues. Writing ?ai-run there would create a non-reloadable
+// pseudo-link. The embedded /c/:id Radar tree and local Radar own their route and
+// therefore keep the query as navigation state; Fleet copies run.radarUrl instead.
+function diagnoseURLStateEnabled(browserURLState: boolean): boolean {
+  if (!browserURLState) return false;
+  const clusterScopedAPI = /\/c\/[^/]+\/api\/?$/.test(getApiBase());
+  return !clusterScopedAPI || /^\/c\/[^/]+/.test(window.location.pathname);
+}
+
+export function DiagnoseProvider({
+  children,
+  browserURLState = true,
+}: {
+  children: ReactNode;
+  browserURLState?: boolean;
+}) {
   const [available, setAvailable] = useState(false);
   const [eligible, setEligible] = useState(false);
   const [agents, setAgents] = useState<AgentInfo[]>([]);
@@ -206,6 +261,26 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
   const [open, setOpen] = useState(false);
   const [view, setView] = useState<DiagnoseView>("home");
   const [activeRunId, setActiveRunId] = useState<string | null>(null);
+  const activeRunIdRef = useRef(activeRunId);
+  activeRunIdRef.current = activeRunId;
+  // A missing/revoked durable link is terminal until the user explicitly
+  // navigates to it again. Keep polling the bounded history list (so a newly
+  // shared run can reappear), but do not hammer the exact 404 endpoint every
+  // four seconds while the unavailable state is already on screen.
+  const unavailableRunIDsRef = useRef(new Set<string>());
+  // Tracks whether the panel focus belongs to browser history. Fleet opens the
+  // same panel on /issues, where URL state is deliberately disabled; a generic
+  // panel launch must never be closed by the deep-link synchronization effect.
+  const urlRunIdRef = useRef(runIDFromLocation(browserURLState));
+  const writeFocusedRunID = useCallback(
+    (id: string | null, push: boolean) => {
+      // Set this before writeRunIDToLocation's synthetic popstate so our own
+      // listener can distinguish a programmatic close/home write from Back.
+      if (diagnoseURLStateEnabled(browserURLState)) urlRunIdRef.current = id;
+      writeRunIDToLocation(id, push, browserURLState);
+    },
+    [browserURLState],
+  );
   const [runs, setRuns] = useState<RunSummary[]>([]);
   const [runsLoaded, setRunsLoaded] = useState(false);
   const [runsLoadFailed, setRunsLoadFailed] = useState(false);
@@ -332,28 +407,79 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     return () => window.removeEventListener("resize", onResize);
   }, []);
 
-  const refreshRuns = useCallback(() => {
+  const refreshRuns = useCallback(async () => {
     if (!available) return;
-    listRuns()
-      .then((r) => {
-        setRuns(r.runs);
-        setRunsLoaded(true);
-        setRunsLoadFailed(false);
-        setHistoryDegraded(!!r.historyDegraded);
-      })
-      .catch(() => {
-        // Leave runsLoaded false (a missing-run verdict needs a real list) but
-        // record the failure so the panel can say "retrying" instead of
-        // pretending nothing happened. The 4s poll keeps retrying while open.
-        setRunsLoadFailed(true);
+    try {
+      const r = await listRuns();
+      const focusedID = activeRunIdRef.current;
+      let focusedRun: RunSummary | null = null;
+      let retainFocusedSnapshot = false;
+      const listedFocusedRun = focusedID
+        ? r.runs.find((run) => run.id === focusedID)
+        : undefined;
+      if (focusedID && listedFocusedRun) {
+        unavailableRunIDsRef.current.delete(focusedID);
+      } else if (focusedID && !unavailableRunIDsRef.current.has(focusedID)) {
+        try {
+          // A stable deep link can target a retained run older than the bounded
+          // history page. Refresh it directly too: its status and capabilities
+          // must not freeze at the first snapshot while the panel stays open.
+          focusedRun = await getRun(focusedID);
+        } catch (error) {
+          // The bounded list is still authoritative for everything else. A
+          // missing/revoked focused run falls out and renders unavailable;
+          // transient direct-fetch failures keep the last useful snapshot.
+          const unavailable =
+            error instanceof DiagnoseError && error.status === 404;
+          if (unavailable) unavailableRunIDsRef.current.add(focusedID);
+          retainFocusedSnapshot = !unavailable;
+        }
+      }
+      setRuns((prev) => {
+        let nextRuns = r.runs;
+        if (focusedRun) nextRuns = [focusedRun, ...nextRuns];
+        if (focusedID && retainFocusedSnapshot) {
+          const previous = prev.find((run) => run.id === focusedID);
+          if (previous) nextRuns = [previous, ...nextRuns];
+        }
+
+        // openRun/start can focus and insert a run while the direct fetch above
+        // is in flight. Preserve that newer focus instead of replacing it with
+        // the snapshot for the run that was active when this refresh started.
+        const currentFocusedID = activeRunIdRef.current;
+        if (
+          currentFocusedID &&
+          currentFocusedID !== focusedID &&
+          !nextRuns.some((run) => run.id === currentFocusedID)
+        ) {
+          const current = prev.find((run) => run.id === currentFocusedID);
+          if (current) nextRuns = [current, ...nextRuns];
+        }
+        return nextRuns;
       });
+      setRunsLoaded(true);
+      setRunsLoadFailed(false);
+      setHistoryDegraded(!!r.historyDegraded);
+    } catch {
+      // Leave runsLoaded false (a missing-run verdict needs a real list) but
+      // record the failure so the panel can say "retrying" instead of
+      // pretending nothing happened. The 4s poll keeps retrying while open.
+      setRunsLoadFailed(true);
+    }
   }, [available]);
+  const updateRunSummary = useCallback((run: RunSummary) => {
+    setRuns((prev) =>
+      prev.some((item) => item.id === run.id)
+        ? prev.map((item) => (item.id === run.id ? run : item))
+        : [run, ...prev],
+    );
+  }, []);
 
-  // A content-stable signature of the resources with a live (running) investigation,
+  // A content-stable signature of the resources with a live investigation,
   // so the per-resource Diagnose buttons can show a "running" indicator even with the
   // panel closed — and only re-render when the set actually changes, not every poll.
   const runningSig = runs
-    .filter((r) => r.status === "running")
+    .filter((r) => r.status === "running" || r.status === "stopping")
     .map((r) => runTargetKey(r.kind, r.namespace, r.name))
     .sort()
     .join("|");
@@ -397,6 +523,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
         if (seq !== startSeqRef.current) return;
         setActiveRunId(run.id);
         setView("investigation");
+        writeFocusedRunID(run.id, true);
       })
       .catch((e) => {
         if (seq !== startSeqRef.current) return;
@@ -431,52 +558,90 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     },
     [consentSurface, hosted],
   );
-  const openRun = useCallback((id: string) => {
-    setStartError(null);
-    setActiveRunId(id);
-    setView("investigation");
-    setOpen(true);
-  }, []);
+  const openRun = useCallback(
+    (id: string) => {
+      unavailableRunIDsRef.current.delete(id);
+      setStartError(null);
+      setActiveRunId(id);
+      setView("investigation");
+      setOpen(true);
+      writeFocusedRunID(id, true);
+      // A Fleet issue can point at a retained automatic run older than the
+      // bounded history page. Resolve the exact id instead of waiting for list.
+      getRun(id)
+        .then(updateRunSummary)
+        .catch((error) => {
+          if (error instanceof DiagnoseError && error.status === 404) {
+            unavailableRunIDsRef.current.add(id);
+          }
+          // The loaded-list state renders the durable unavailable message.
+        });
+    },
+    [updateRunSummary, writeFocusedRunID],
+  );
 
-  // Deep link: ?ai-run=<id> opens the panel focused on that investigation —
-  // the URL `radar diagnose --open` prints/opens. Consumed once (then stripped)
-  // so back/forward and copied URLs don't keep re-opening the panel.
+  // The run id is durable navigation state: direct loads and popstate focus the
+  // exact run, and the query remains in place so the address bar is copyable.
+  // Fetch by id rather than assuming the bounded recent list contains it.
   useEffect(() => {
-    if (!available) return;
-    let id: string | null = null;
-    try {
-      const params = new URLSearchParams(window.location.search);
-      id = params.get("ai-run");
-      if (id) {
-        params.delete("ai-run");
-        const qs = params.toString();
-        window.history.replaceState(
-          null,
-          "",
-          window.location.pathname +
-            (qs ? `?${qs}` : "") +
-            window.location.hash,
-        );
+    if (!available || !diagnoseURLStateEnabled(browserURLState)) return;
+    const focusFromLocation = (fromPopState: boolean) => {
+      const id = runIDFromLocation(browserURLState);
+      if (!id) {
+        // A missing id on first mount is ordinary. On popstate it means "back
+        // out of this investigation" only when the focused run was itself
+        // installed by URL history; unrelated synthetic popstate events must
+        // not tear down a panel opened by an in-app action.
+        if (fromPopState && urlRunIdRef.current) {
+          setActiveRunId(null);
+          setView("home");
+          setOpen(false);
+        }
+        urlRunIdRef.current = null;
+        return;
       }
-    } catch {
-      /* URL APIs unavailable — skip the deep link */
-    }
-    if (id) openRun(id);
-  }, [available, openRun]);
+      urlRunIdRef.current = id;
+      unavailableRunIDsRef.current.delete(id);
+      setStartError(null);
+      setActiveRunId(id);
+      setView("investigation");
+      setOpen(true);
+      getRun(id)
+        .then(updateRunSummary)
+        .catch((error) => {
+          if (error instanceof DiagnoseError && error.status === 404) {
+            unavailableRunIDsRef.current.add(id);
+          }
+          // The list load owns the final missing/degraded state and keeps retrying.
+        });
+    };
+    focusFromLocation(false);
+    const onPopState = () => focusFromLocation(true);
+    window.addEventListener("popstate", onPopState);
+    return () => window.removeEventListener("popstate", onPopState);
+  }, [available, browserURLState, updateRunSummary]);
   // Leaving the detail pane drops the failure that belonged to it. startError
   // renders as the entire pane (maximized home still shows `detail`), where a
   // message about a resource you just navigated away from has nothing to attach
   // to and no way to be dismissed.
   const openHome = useCallback(() => {
+    unavailableRunIDsRef.current.clear();
     setView("home");
     setStartError(null);
     setOpen(true);
-  }, []);
+    writeFocusedRunID(null, false);
+  }, [writeFocusedRunID]);
   const goHome = useCallback(() => {
+    unavailableRunIDsRef.current.clear();
     setView("home");
     setStartError(null);
-  }, []);
-  const close = useCallback(() => setOpen(false), []);
+    writeFocusedRunID(null, false);
+  }, [writeFocusedRunID]);
+  const close = useCallback(() => {
+    unavailableRunIDsRef.current.clear();
+    setOpen(false);
+    writeFocusedRunID(null, false);
+  }, [writeFocusedRunID]);
   const consentBusyRef = useRef(false);
   const approveConsent = useCallback(() => {
     if (consentBusyRef.current) return;
@@ -557,6 +722,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     approveConsent,
     cancelConsent,
     refreshRuns,
+    updateRunSummary,
     dismissError,
   };
 
@@ -567,6 +733,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
   const layout = useMemo<DiagnoseLayoutCtx>(
     () => ({
       open,
+      close,
       contentGutter,
       maximized,
       setMaximized,
@@ -579,6 +746,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     }),
     [
       open,
+      close,
       contentGutter,
       maximized,
       width,