@@ -58,6 +58,7 @@ import {
   pageCheck,
   runLoad,
   runLoadId,
+  runOpensExpanded,
   runSpanCount,
   sessionRunLoadsReducer,
   type SessionRunLoad,
@@ -239,7 +240,7 @@ function SessionTraceTree({
   }
   const intended = local ?? selection;
 
-  // Captured once: runs added later (earlier pages, new runs) start collapsed.
+  // Captured once. Runs added later start collapsed, apart from a new newest run (the reducer).
   const [openRunId] = useState(() => initiallyExpandedRunFriendlyId(runs, totalCount));
   // A selection in the URL at mount whose run loaded: open there instead of at the bottom.
   const [deepLink] = useState(() => {
@@ -382,10 +383,10 @@ function SessionTraceTree({
     estimatedRowHeight: () => ROW_HEIGHT_PX,
     // Arrow keys, Home and End skip the gap, "not loaded" and "Load earlier" rows.
     canSelect: (node) => isSelectableRow(node.data),
+    // The load reducer owns which runs are expanded: the opening run, a deep link, a new run.
     isCollapsedByDefault: (node) =>
       node.data.kind === "run" &&
-      node.data.run.friendlyId !== openRunId &&
-      node.data.run.friendlyId !== deepLink?.runFriendlyId,
+      !runOpensExpanded(loadsRef.current, node.data.run.friendlyId, newestRunId),
     canExpand: (node) => node.data.kind === "run" || node.hasChildren,
     structureKey,
     // Derived, never set by code: a span not in the tree yet highlights its run.
@@ -522,10 +523,11 @@ function SessionTraceTree({
     onLoadEarlier();
   };
 
-  // Follow the newest run's new spans, but only if the view was at the bottom when they arrived.
-  // `atBottom` is tracked on scroll, so rows added without a scroll (a new run) keep it true.
+  // Follow a new run and the newest run's new spans, but only if the view was at the bottom when
+  // they arrived. `atBottom` is tracked on scroll, so rows added without a scroll keep it true.
   // The tree takes the new rows a render later, so scroll once its node state has changed.
   const newestSpanCount = newestRunId ? (snapshots[newestRunId]?.events.length ?? 0) : 0;
+  const followKey = `${newestRunId}:${newestSpanCount}`;
   const pendingFollow = useRef<{ nodes: typeof nodes } | null>(null);
   const latestNodes = useRef(nodes);
   useLayoutEffect(() => {
@@ -537,13 +539,13 @@ function SessionTraceTree({
     const scrollElement = parentRef.current;
     if (scrollElement && atBottom.current) scrollElement.scrollTop = scrollElement.scrollHeight;
   }, [nodes]);
-  const followedSpanCount = useRef(newestSpanCount);
+  const followedKey = useRef(followKey);
   useLayoutEffect(() => {
-    if (followedSpanCount.current === newestSpanCount) return;
-    followedSpanCount.current = newestSpanCount;
+    if (followedKey.current === followKey) return;
+    followedKey.current = followKey;
     pendingFollow.current =
       atBottom.current && !earlierLoad.current ? { nodes: latestNodes.current } : null;
-  }, [newestSpanCount]);
+  }, [followKey]);
 
   // Run rows always expand and collapse one by one, so the load reducer hears about each.
   // Expand all tells it first, newest first, so the newest runs load first; the per-row
 
@@ -118,6 +118,34 @@ export function isRunTraceMounted(load: SessionRunLoad): boolean {
   }
 }
 
+/**
+ * A run that just became the newest, replacing a known one, opens expanded, unless the user has
+ * already expanded or collapsed it. Several new runs at once open only the newest.
+ */
+function newRunToOpen(
+  current: SessionRunLoads,
+  newestRunId: string | undefined
+): string | undefined {
+  const previous = current.newestRunId;
+  if (!previous || !newestRunId || previous === newestRunId) return undefined;
+  if (current.expanded.has(newestRunId) || current.collapsedOrder.includes(newestRunId)) {
+    return undefined;
+  }
+  return newestRunId;
+}
+
+/**
+ * Whether a run row opens expanded when it first appears in the tree. Asks the same question as
+ * `runsChanged`, so the answer doesn't depend on whether that event has been handled yet.
+ */
+export function runOpensExpanded(
+  loads: SessionRunLoads,
+  runFriendlyId: string,
+  newestRunId: string | undefined
+): boolean {
+  return loads.expanded.has(runFriendlyId) || newRunToOpen(loads, newestRunId) === runFriendlyId;
+}
+
 /** The starting state, with the run that opens expanded. */
 export function createSessionRunLoads(
   expandedRunIds: string[] = [],
@@ -154,10 +182,12 @@ function runLoadedSpans(loads: SessionRunLoads, runFriendlyId: string): number {
  * Every decision about loading a run's trace lives here:
  * - An expanded run that is in the run store and idle loads, whenever that becomes true.
  * - Expanding a failed run reads it again, but only if none of its spans are on screen.
- * - At most 3 runs load at once; a run holds its slot until all its pages are in.
+ * - At most 3 runs load at once; a run holds its slot until all its pages are in. The newest run
+ *   starts first when it's queued.
  * - A run that settled with no spans becomes loaded when its first span arrives while tailing.
- * - When a newer run takes over, the previous newest run is read afresh once if it was still empty.
- * - A deep-linked run expands first, so it's the first to load once it's in the run store.
+ * - When a newer run takes over, it expands; the previous newest run keeps its state, and is read
+ *   afresh once if it was still empty.
+ * - A deep-linked run expands first, so it loads ahead of every run but the newest.
  * - The span budget: a run starts or fetches a page only within it, after freeing the least
  *   recently collapsed runs if that's enough; the newest run is never held back. A run that would
  *   fit with its own page waits while others load, rather than being cut off.
@@ -209,6 +239,8 @@ export function sessionRunLoadsReducer(
       ) {
         next = withoutLoads(next, [previous]);
       }
+      const opened = newRunToOpen(current, action.newestRunId);
+      if (opened) next = { ...next, expanded: new Set([...next.expanded, opened]) };
       return loadWanted(next);
     }
     case "spanCount": {
@@ -392,11 +424,13 @@ function startQueued(current: SessionRunLoads): SessionRunLoads {
   let inFlight = inFlightCount(current);
   if (inFlight >= MAX_CONCURRENT_RUN_LOADS || current.queue.length === 0) return current;
 
-  let next: SessionRunLoads = {
-    ...current,
-    loads: { ...current.loads },
-    queue: [...current.queue],
-  };
+  // The newest run never waits behind older runs: it's the one being watched.
+  const newest = current.newestRunId;
+  const queue =
+    newest && current.queue.includes(newest)
+      ? [newest, ...current.queue.filter((id) => id !== newest)]
+      : [...current.queue];
+  let next: SessionRunLoads = { ...current, loads: { ...current.loads }, queue };
   // Runs that would fit once the others finish stay queued, in order.
   const waiting: string[] = [];
   while (inFlight < MAX_CONCURRENT_RUN_LOADS) {
 
@@ -141,22 +141,25 @@ export class SessionRunsPresenter {
       : undefined;
     if (anchor === null) return null;
 
-    const [rows, totalCount] = await Promise.all([
+    // The newest page's top row is the newest run, so its number is the total. A separate count
+    // can see a run the rows don't have yet, and the newest run would look not loaded.
+    const isNewestPage = !query.after && !anchor;
+    const [rows, countedTotal] = await Promise.all([
       findSessionRunsPage(replica, {
         sessionId,
         before: query.after,
         atOrBefore: anchor,
         take: query.pageSize + 1,
       }),
-      countSessionRuns(replica, { sessionId }),
+      isNewestPage ? undefined : countSessionRuns(replica, { sessionId }),
     ]);
 
     const pageRows = rows.slice(0, query.pageSize);
     const olderRow = rows.at(query.pageSize);
     const oldestRow = pageRows.at(-1);
 
     if (!oldestRow) {
-      return { data: [], pagination: {}, totalCount, view: {} };
+      return { data: [], pagination: {}, totalCount: countedTotal ?? 0, view: {} };
     }
 
     const [oldestNumber, runsById] = await Promise.all([
@@ -177,7 +180,7 @@ export class SessionRunsPresenter {
     return {
       data,
       pagination: olderRow ? { next: encodeSessionRunCursor(oldestRow) } : {},
-      totalCount,
+      totalCount: countedTotal ?? oldestNumber + pageRows.length - 1,
       view: this.#view(pageRows, runsById, query.showDeletedLogs),
     };
   }
 
@@ -230,6 +230,36 @@ describe("SessionRunsPresenter", () => {
     expect(second?.totalCount).toBe(24);
   });
 
+  postgresTest(
+    "a run added after the page read doesn't change the newest page's total",
+    async ({ prisma }) => {
+      const { deps, query, addRun } = await seedSessionWithRuns(prisma, 23);
+      // A run is triggered right after the page rows are read, and any other read waits for it:
+      // a count would then see 24 runs while the rows end at 23.
+      let runAdded!: () => void;
+      const added = new Promise<void>((resolve) => (runAdded = resolve));
+      const replica = new Proxy(prisma, {
+        get(target, prop, receiver) {
+          if (prop !== "$queryRaw") return Reflect.get(target, prop, receiver);
+          return async (sql: { sql: string }, ...values: unknown[]) => {
+            if (!sql.sql.includes("LIMIT")) {
+              await added;
+              return target.$queryRaw(sql as never, ...values);
+            }
+            const rows = await target.$queryRaw(sql as never, ...values);
+            await addRun(24);
+            runAdded();
+            return rows;
+          };
+        },
+      });
+
+      const page = await new SessionRunsPresenter({ ...deps, replica }).call(query);
+      expect(page?.data[0]?.number).toBe(23);
+      expect(page?.totalCount).toBe(23);
+    }
+  );
+
   postgresTest("afterCrash sees a crashed run on the previous page", async ({ prisma }) => {
     const { deps, query } = await seedSessionWithRuns(prisma, 23, (n) =>
       n === 3 ? { status: "CRASHED" } : {}
 
@@ -15,6 +15,7 @@ import {
   pageCheck,
   runLoad,
   runLoadId,
+  runOpensExpanded,
   runSpanCount,
   sessionRunLoadsReducer,
   type SessionRunLoadOutcome,
@@ -1041,6 +1042,124 @@ describe("sessionRunLoadsReducer: what loads when", () => {
   });
 });
 
+describe("sessionRunLoadsReducer: new runs", () => {
+  type Action = SessionRunLoadsAction;
+  const run = (loads: SessionRunLoads, ...actions: Action[]) =>
+    actions.reduce<SessionRunLoads>(sessionRunLoadsReducer, loads);
+  const runsChanged = (withStatus: string[], newestRunId?: string): Action => ({
+    type: "runsChanged",
+    withStatus,
+    newestRunId,
+  });
+  const expand = (id: string, expanded = true): Action => ({
+    type: "expanded",
+    runFriendlyId: id,
+    expanded,
+  });
+  const opened = () => run(createSessionRunLoads(["run_25"]), runsChanged(["run_25"], "run_25"));
+
+  it("expands a new newest run and loads it", () => {
+    const loads = run(opened(), runsChanged(["run_25", "run_26"], "run_26"));
+    expect(loads.expanded.has("run_26")).toBe(true);
+    expect(runLoad(loads, "run_26").state).toBe("loading");
+  });
+
+  it("leaves the previous run as it was, expanded or collapsed", () => {
+    const stillOpen = run(opened(), runsChanged(["run_25", "run_26"], "run_26"));
+    expect(stillOpen.expanded.has("run_25")).toBe(true);
+
+    const collapsed = run(
+      opened(),
+      expand("run_25", false),
+      runsChanged(["run_25", "run_26"], "run_26")
+    );
+    expect(collapsed.expanded.has("run_25")).toBe(false);
+    expect(collapsed.expanded.has("run_26")).toBe(true);
+  });
+
+  it("expands only the newest of several new runs", () => {
+    const loads = run(opened(), runsChanged(["run_25", "run_26", "run_27", "run_28"], "run_28"));
+    expect([...loads.expanded].sort()).toEqual(["run_25", "run_28"]);
+    expect(runLoad(loads, "run_26").state).toBe("idle");
+    expect(runLoad(loads, "run_27").state).toBe("idle");
+  });
+
+  it("expands nothing on the first read or when older runs are added", () => {
+    const first = run(createSessionRunLoads(), runsChanged(["run_24", "run_25"], "run_25"));
+    expect(first.expanded.size).toBe(0);
+
+    const earlier = run(opened(), runsChanged(["run_5", "run_6", "run_25"], "run_25"));
+    expect([...earlier.expanded]).toEqual(["run_25"]);
+  });
+
+  it("keeps a new run without a status expanded until it reaches the run store", () => {
+    let loads = run(opened(), runsChanged(["run_25"], "run_26"));
+    expect(loads.expanded.has("run_26")).toBe(true);
+    expect(runLoad(loads, "run_26").state).toBe("idle");
+    loads = run(loads, runsChanged(["run_25", "run_26"], "run_26"));
+    expect(runLoad(loads, "run_26").state).toBe("loading");
+  });
+
+  it("starts a new run at the next free slot, ahead of older queued runs", () => {
+    const older = Array.from({ length: 20 }, (_, i) => `run_${i + 1}`);
+    let loads = run(createSessionRunLoads(), runsChanged(older, "run_20"));
+    loads = run(loads, { type: "expandedMany", runFriendlyIds: [...older].reverse() });
+    expect(loads.queue).toHaveLength(17);
+
+    // The new run reaches the run store a poll after it appears.
+    loads = run(loads, runsChanged(older, "run_21"), runsChanged([...older, "run_21"], "run_21"));
+    expect(runLoad(loads, "run_21").state).toBe("queued");
+
+    const loading = runLoad(loads, "run_20");
+    if (loading.state !== "loading") throw new Error("run_20 isn't loading");
+    loads = run(loads, {
+      type: "settle",
+      runFriendlyId: "run_20",
+      loadId: loading.loadId,
+      outcome: { state: "progressive" },
+    });
+    expect(runLoad(loads, "run_21").state).toBe("loading");
+  });
+
+  it("doesn't reopen a run the user collapsed if it becomes the newest again", () => {
+    const loads = run(
+      opened(),
+      runsChanged(["run_25", "run_26"], "run_26"),
+      expand("run_26", false),
+      runsChanged(["run_25", "run_26"], "run_25"),
+      runsChanged(["run_25", "run_26"], "run_26")
+    );
+    expect(loads.expanded.has("run_26")).toBe(false);
+  });
+
+  describe("runOpensExpanded", () => {
+    it("gives the tree the same answer before and after runsChanged is handled", () => {
+      const before = opened();
+      const after = run(before, runsChanged(["run_25", "run_26"], "run_26"));
+      for (const loads of [before, after]) {
+        expect(runOpensExpanded(loads, "run_26", "run_26")).toBe(true);
+        expect(runOpensExpanded(loads, "run_25", "run_26")).toBe(true);
+      }
+    });
+
+    it("opens the starting and deep-linked runs, and nothing else", () => {
+      const loads = run(createSessionRunLoads(["run_25"]), {
+        type: "deepLinked",
+        runFriendlyId: "run_3",
+      });
+      expect(runOpensExpanded(loads, "run_25", undefined)).toBe(true);
+      expect(runOpensExpanded(loads, "run_3", undefined)).toBe(true);
+      expect(runOpensExpanded(loads, "run_4", undefined)).toBe(false);
+      // The first read of the newest run isn't a new run.
+      expect(runOpensExpanded(loads, "run_24", "run_25")).toBe(false);
+    });
+
+    it("doesn't open older runs added by Load earlier", () => {
+      expect(runOpensExpanded(opened(), "run_5", "run_25")).toBe(false);
+    });
+  });
+});
+
 describe("sessionRunLoadsReducer: deep links", () => {
   const deepLinked = (id: string): SessionRunLoadsAction => ({
     type: "deepLinked",
@@ -1052,22 +1171,23 @@ describe("sessionRunLoadsReducer: deep links", () => {
     newestRunId,
   });
 
-  it("expands the linked run and loads it ahead of the live run", () => {
+  it("expands the linked run and loads it with the live run", () => {
     let loads = sessionRunLoadsReducer(createSessionRunLoads(["run_50"]), deepLinked("run_3"));
     expect([...loads.expanded]).toEqual(["run_3", "run_50"]);
 
     loads = sessionRunLoadsReducer(loads, runsChanged(["run_3", "run_50"], "run_50"));
-    expect(runLoad(loads, "run_3")).toEqual({ state: "loading", loadId: 1 });
-    expect(runLoad(loads, "run_50")).toEqual({ state: "loading", loadId: 2 });
+    expect(runLoad(loads, "run_3").state).toBe("loading");
+    expect(runLoad(loads, "run_50").state).toBe("loading");
   });
 
   it("moves a queued linked run to the front", () => {
     const ids = ["run_1", "run_2", "run_3", "run_4", "run_5"];
     let loads = sessionRunLoadsReducer(createSessionRunLoads(ids), runsChanged(ids, "run_5"));
-    expect(loads.queue).toEqual(["run_4", "run_5"]);
+    // The newest run starts first.
+    expect(loads.queue).toEqual(["run_3", "run_4"]);
 
-    loads = sessionRunLoadsReducer(loads, deepLinked("run_5"));
-    expect(loads.queue).toEqual(["run_5", "run_4"]);
+    loads = sessionRunLoadsReducer(loads, deepLinked("run_4"));
+    expect(loads.queue).toEqual(["run_4", "run_3"]);
   });
 
   it("waits for the linked run to reach the run store", () => {