@@ -15,6 +15,7 @@ import {
 } from "./sessionPanelStore";
 import { SESSION_SPAN_TAB_PARAM, type SessionTraceSelection } from "./sessionTraceSelection";
 import { fetchRunsPage } from "./useSessionRunPages";
+import { useSessionViewAnalytics } from "./useSessionViewAnalytics";
 
 type RunOrSpanSelection = Exclude<SessionTraceSelection, { kind: "session" }>;
 
@@ -29,6 +30,7 @@ export function SessionRunInspector({
   runsPath: string;
   onClose: () => void;
 }) {
+  const track = useSessionViewAnalytics();
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
@@ -85,7 +87,11 @@ export function SessionRunInspector({
       ? v3RunSpanPath(organization, project, environment, run, { spanId: selection.spanId })
       : v3RunPath(organization, project, environment, run);
   const openRunPage = (
-    <LinkButton variant="secondary/small" to={runPagePath}>
+    <LinkButton
+      variant="secondary/small"
+      to={runPagePath}
+      onClick={() => track("open_run_page", { from: "panel" })}
+    >
       Open run page
     </LinkButton>
   );
 
@@ -100,6 +100,8 @@ import {
   type SearchCoverage,
   type SessionTraceFilter,
 } from "./sessionTraceSearch";
+import { newBudgetOutcomes, searchStarted, type BudgetOutcome } from "./sessionViewAnalytics";
+import { useSessionViewAnalytics } from "./useSessionViewAnalytics";
 import type { SessionTraceRun } from "./sessionTraceTypes";
 import { SESSION_TREE_AUTOSAVE_ID, runReasonLabel } from "./sessionTraceView";
 import {
@@ -151,9 +153,18 @@ export function SessionTraceTab({
     interval: newRunsPollIntervalMs(pages.runs ?? [], pages.totalCount, checkedAtMs),
     disabled: pages.state.status !== "ready",
     onLoad: false,
+    onFocus: false,
     callback: () => {
       setCheckedAtMs(Date.now());
-      pages.refreshNewest();
+      pages.refreshNewest("poll");
+    },
+  });
+  useInterval({
+    disabled: pages.state.status !== "ready",
+    onLoad: false,
+    callback: () => {
+      setCheckedAtMs(Date.now());
+      pages.refreshNewest("focus");
     },
   });
 
@@ -304,6 +315,22 @@ function SessionTraceTree({
   // The page check runs between renders, so it reads a ref that every event updates at once,
   // with the same reducer React runs: a count or a release just sent is never missed.
   const loadsRef = useRef(loads);
+  const track = useSessionViewAnalytics(runs.length);
+  // Budget reached: each outcome once per page view (Expand all near the limit hits it often).
+  const reportedBudget = useRef(new Set<BudgetOutcome>());
+  const lastBudgetHits = useRef(loads.budgetHits);
+  useEffect(() => {
+    const outcomes = newBudgetOutcomes(
+      lastBudgetHits.current,
+      loads.budgetHits,
+      reportedBudget.current
+    );
+    lastBudgetHits.current = loads.budgetHits;
+    for (const outcome of outcomes) {
+      reportedBudget.current.add(outcome);
+      track("budget_reached", { outcome });
+    }
+  }, [loads.budgetHits, track]);
   const dispatchLoads = useCallback((action: SessionRunLoadsAction) => {
     loadsRef.current = sessionRunLoadsReducer(loadsRef.current, action);
     reactDispatchLoads(action);
@@ -618,10 +645,12 @@ function SessionTraceTree({
       ),
     };
     newestFirst.runFriendlyIds.reverse();
+    track("expand_all", { runs: newestFirst.runFriendlyIds.length });
     dispatchLoads(newestFirst);
     expandNodes(collapsed.map((node) => node.id));
   };
   const retryRun = (runFriendlyId: string) => {
+    track("retry");
     dispatchLoads({ type: "retry", runFriendlyId });
     const id = runNodeId(runFriendlyId);
     if (!nodes[id]?.expanded) expandNode(id, false);
@@ -677,6 +706,7 @@ function SessionTraceTree({
   );
   const loadAllForSearch = () => {
     if (coverage.toLoad.length === 0) return;
+    track("load_all", { runs: coverage.toLoad.length });
     for (const id of coverage.toLoad) openedForSearch.current.add(id);
     dispatchLoads({ type: "expandedMany", runFriendlyIds: coverage.toLoad });
     searchMovingRows.current = true;
@@ -697,6 +727,9 @@ function SessionTraceTree({
     next.text = next.text.toLowerCase();
     if (!isFiltering(next)) next.hiddenRuns = [];
     setFilter(next);
+    if (searchStarted(filter, next)) {
+      track("search_used", { text: next.text !== "", errors_only: next.errorsOnly });
+    }
     if (!filtering || isFiltering(next)) return;
 
     const keep = new Set(touchedDuringSearch.current);
@@ -1294,6 +1327,7 @@ function RunRowContent({
 
 // A run whose trace can't load here links to its run page instead of expanding.
 function RunFallback({ run, block }: { run: SessionTraceRun; block: RunLoadBlock }) {
+  const track = useSessionViewAnalytics();
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
@@ -1313,7 +1347,10 @@ function RunFallback({ run, block }: { run: SessionTraceRun; block: RunLoadBlock
       <LinkButton
         variant="secondary/small"
         to={v3RunPath(organization, project, environment, run)}
-        onClick={(event) => event.stopPropagation()}
+        onClick={(event) => {
+          event.stopPropagation();
+          track("open_run_page", { from: "row", reason: block.kind });
+        }}
       >
         Open run page
       </LinkButton>
@@ -1337,6 +1374,7 @@ function RunLoadStatus({
   spanCount: number;
   onRetry: (runFriendlyId: string) => void;
 }) {
+  const track = useSessionViewAnalytics();
   const organization = useOrganization();
   const project = useProject();
   const environment = useEnvironment();
@@ -1395,7 +1433,10 @@ function RunLoadStatus({
           <LinkButton
             variant="secondary/small"
             to={v3RunPath(organization, project, environment, run)}
-            onClick={(event) => event.stopPropagation()}
+            onClick={(event) => {
+              event.stopPropagation();
+              track("open_run_page", { from: "row", reason: "cutOff" });
+            }}
           >
             Open run page
           </LinkButton>
 
@@ -60,6 +60,8 @@ export type SessionRunLoads = {
   /** The session's newest run, when it's loaded. */
   newestRunId: string | undefined;
   budget: number;
+  /** How often the budget freed collapsed runs or cut one off, for analytics. */
+  budgetHits: { freed: number; cutOff: number };
 };
 
 export type SessionRunLoadsAction =
@@ -85,7 +87,7 @@ export type SessionRunLoadsAction =
   /** Retry a failed run: in place when some of its spans are on screen, else from the start. */
   | { type: "retry"; runFriendlyId: string }
   /** Frees runs back to idle, cancelling a fetch in flight (its late settle won't match). */
-  | { type: "release"; runFriendlyIds: string[] };
+  | { type: "release"; runFriendlyIds: string[]; forBudget?: boolean };
 
 /** What to do before a run fetches its next page. */
 type PageDecision =
@@ -171,6 +173,7 @@ export function createSessionRunLoads(
     selectedRunId: undefined,
     newestRunId: undefined,
     budget,
+    budgetHits: { freed: 0, cutOff: 0 },
   };
 }
 
@@ -300,7 +303,7 @@ export function sessionRunLoadsReducer(
       const over = loadedTotal(next) - next.budget;
       if (over <= 0) return next;
       const freeable = freeableRuns(next);
-      return withoutLoads(next, takeUntil(next, freeable, over) ?? freeable);
+      return freeForBudget(next, takeUntil(next, freeable, over) ?? freeable);
     }
     case "selected": {
       if (current.selectedRunId === action.runFriendlyId) return current;
@@ -318,7 +321,9 @@ export function sessionRunLoadsReducer(
               attempt: load.state === "paging" ? load.attempt : 0,
             }
           : { ...action.outcome, loadId: load.loadId };
-      return startQueued({ ...current, loads: { ...current.loads, [action.runFriendlyId]: next } });
+      const settled = { ...current, loads: { ...current.loads, [action.runFriendlyId]: next } };
+      const cutBySession = action.outcome.state === "cutOff" && action.outcome.limit === "session";
+      return startQueued(cutBySession ? countCutOff(settled) : settled);
     }
     case "retry": {
       const { runFriendlyId: id } = action;
@@ -334,7 +339,9 @@ export function sessionRunLoadsReducer(
     case "release": {
       const released = action.runFriendlyIds.filter((id) => id in current.loads);
       if (released.length === 0) return current;
-      return loadWanted(withoutLoads(current, released));
+      return loadWanted(
+        action.forBudget ? freeForBudget(current, released) : withoutLoads(current, released)
+      );
     }
   }
 }
@@ -359,7 +366,7 @@ export function pageCheck(
     case "free":
       return {
         allowed: true,
-        action: { type: "release", runFriendlyIds: decision.runFriendlyIds },
+        action: { type: "release", runFriendlyIds: decision.runFriendlyIds, forBudget: true },
       };
     case "cutOff": {
       const load = runLoad(current, runFriendlyId);
@@ -424,6 +431,17 @@ function enqueue(current: SessionRunLoads, runFriendlyIds: string[]): SessionRun
   return { ...current, loads, queue: [...current.queue, ...runFriendlyIds] };
 }
 
+function freeForBudget(current: SessionRunLoads, runFriendlyIds: string[]): SessionRunLoads {
+  if (runFriendlyIds.length === 0) return current;
+  const { freed, cutOff } = current.budgetHits;
+  return { ...withoutLoads(current, runFriendlyIds), budgetHits: { freed: freed + 1, cutOff } };
+}
+
+function countCutOff(current: SessionRunLoads): SessionRunLoads {
+  const { freed, cutOff } = current.budgetHits;
+  return { ...current, budgetHits: { freed, cutOff: cutOff + 1 } };
+}
+
 function withoutLoads(current: SessionRunLoads, runFriendlyIds: string[]): SessionRunLoads {
   if (runFriendlyIds.length === 0) return current;
   const removed = new Set(runFriendlyIds);
@@ -489,15 +507,17 @@ function startQueued(current: SessionRunLoads): SessionRunLoads {
       if (over > 0) {
         const toFree = takeUntil(next, freeableRuns(next), over);
         if (!toFree) {
-          next = settleAt(next, id, {
-            state: "cutOff",
-            limit: "session",
-            started: false,
-            spanLimit: next.budget,
-          });
+          next = countCutOff(
+            settleAt(next, id, {
+              state: "cutOff",
+              limit: "session",
+              started: false,
+              spanLimit: next.budget,
+            })
+          );
           continue;
         }
-        next = withoutLoads(next, toFree);
+        next = freeForBudget(next, toFree);
       }
     }
 
 
@@ -0,0 +1,52 @@
+export const SESSION_VIEW_EVENT = "session_view_action";
+
+export type SessionViewAction =
+  | "expand_all"
+  | "load_all"
+  | "search_used"
+  | "budget_reached"
+  | "open_run_page"
+  | "retry"
+  | "conversation_opened";
+
+export type SessionViewer = "member" | "admin" | "impersonating";
+
+export type SessionViewProperties = Record<string, string | number | boolean | undefined>;
+
+export function sessionViewer(admin: boolean | undefined, impersonating: boolean): SessionViewer {
+  if (impersonating) return "impersonating";
+  return admin ? "admin" : "member";
+}
+
+export function sessionViewEventProperties(
+  action: SessionViewAction,
+  shared: { viewer: SessionViewer; runsShown?: number },
+  extra: SessionViewProperties = {}
+): SessionViewProperties {
+  return { ...extra, action, viewer: shared.viewer, runs_shown: shared.runsShown };
+}
+
+export type BudgetHits = { freed: number; cutOff: number };
+export type BudgetOutcome = "freed" | "cut_off";
+
+/** Budget outcomes to report: each one once per page view, the first time it happens. */
+export function newBudgetOutcomes(
+  previous: BudgetHits,
+  next: BudgetHits,
+  reported: ReadonlySet<BudgetOutcome>
+): BudgetOutcome[] {
+  const outcomes: BudgetOutcome[] = [];
+  if (next.freed > previous.freed && !reported.has("freed")) outcomes.push("freed");
+  if (next.cutOff > previous.cutOff && !reported.has("cut_off")) outcomes.push("cut_off");
+  return outcomes;
+}
+
+/** "Search used" fires when a search starts, not on every keystroke. */
+export function searchStarted(
+  previous: { text: string; errorsOnly: boolean },
+  next: { text: string; errorsOnly: boolean }
+): boolean {
+  const wasSearching = previous.text !== "" || previous.errorsOnly;
+  const isSearching = next.text !== "" || next.errorsOnly;
+  return !wasSearching && isSearching;
+}
@@ -33,19 +33,23 @@ type PagesState =
 /** What became of the deep-linked run, if the page opened with one. */
 export type DeepLinkResult = "none" | "loaded" | "notFound" | "failed";
 
+/** Why the newest page is read; the route labels its metrics with it. */
+export type NewestPageReason = "open" | "focus" | "poll";
+
 export type PageResult =
   | { ok: true; page: SessionRunsPage }
   | { ok: false; status: number | undefined; message: string };
 
 export async function fetchRunsPage(
   runsPath: string,
-  params: { after?: string; size?: number; run?: string },
+  params: { after?: string; size?: number; run?: string; reason?: NewestPageReason },
   signal: AbortSignal
 ): Promise<PageResult> {
   const url = new URL(runsPath, window.location.origin);
   url.searchParams.set("page[size]", String(params.size ?? RUNS_PAGE_SIZE));
   if (params.after) url.searchParams.set("page[after]", params.after);
   if (params.run) url.searchParams.set("run", params.run);
+  if (params.reason) url.searchParams.set("reason", params.reason);
 
   const [error, response] = await tryCatch(fetch(url, { signal }));
   if (error) return { ok: false, status: undefined, message: "Couldn't load this session's runs." };
@@ -143,7 +147,7 @@ export function useSessionRunPages(runsPath: string, deepLinkRunFriendlyId?: str
   useEffect(() => {
     const controller = new AbortController();
     void Promise.all([
-      fetchRunsPage(runsPath, {}, controller.signal),
+      fetchRunsPage(runsPath, { reason: "open" }, controller.signal),
       initialDeepLink
         ? fetchRunsPage(runsPath, { run: initialDeepLink }, controller.signal)
         : undefined,
@@ -218,20 +222,23 @@ export function useSessionRunPages(runsPath: string, deepLinkRunFriendlyId?: str
   );
 
   // Re-reads the newest page, e.g. when a run starts or finishes. Runs already loaded stay.
-  const refreshNewest = useCallback(() => {
-    if (refreshController.current) return;
-    const controller = new AbortController();
-    refreshController.current = controller;
-    void fetchRunsPage(runsPath, {}, controller.signal).then((result) => {
-      if (refreshController.current === controller) refreshController.current = null;
-      if (controller.signal.aborted || !result.ok) return;
-      setState((prev) =>
-        prev.status === "ready"
-          ? { ...prev, loaded: mergeSessionRunPage(prev.loaded, result.page, "newest") }
-          : prev
-      );
-    });
-  }, [runsPath]);
+  const refreshNewest = useCallback(
+    (reason: NewestPageReason = "poll") => {
+      if (refreshController.current) return;
+      const controller = new AbortController();
+      refreshController.current = controller;
+      void fetchRunsPage(runsPath, { reason }, controller.signal).then((result) => {
+        if (refreshController.current === controller) refreshController.current = null;
+        if (controller.signal.aborted || !result.ok) return;
+        setState((prev) =>
+          prev.status === "ready"
+            ? { ...prev, loaded: mergeSessionRunPage(prev.loaded, result.page, "newest") }
+            : prev
+        );
+      });
+    },
+    [runsPath]
+  );
 
   const runs = useMemo(() => (loaded ? [...loaded.runsById.values()] : undefined), [loaded]);