Studio: record a freeze that spans the end of the stream

The stall in progress was measured only while text was still arriving. A
freeze that spans the moment the stream ends blocks the frame loop across
it, so the first frame afterwards already observes a non-null
streamEndedAtMs and the whole frozen interval was skipped. With the lost
tail able to hide inside the 90% workload floor, thirty quiet frames then
settled the reply and the run reported a short longest stall, which is the
one shape this number exists to catch.

Cap the interval at the absolute stream-end timestamp instead. A freeze
across that moment is recorded in full, and the stall stops growing once
there is no more text to wait for, so the settle check's own quiet frames
are still not counted as a freeze.

The rule moves into smoke-stream-pacing-stall.ts so it can be tested
without importing the harness entry, which mounts React on import. The new
tests cover the spanning freeze, the settle-window bound, idempotence and
late tail paint; restoring the previous rule fails two of the five.

Clean runs unchanged (stall 967 to 983ms, long tasks 5,442 to 5,842ms) and
both mutations still caught: #7892 reverted fails the stall at 5,017ms,
#8750 reverted fails long tasks at 63,687ms.

Author: danielhanchen

studio/frontend/smoke-stream-pacing-main.tsx

@@ -39,6 +39,7 @@ import {
 } from "@assistant-ui/react";
 import { type ReactElement, useEffect } from "react";
 import { createRoot } from "react-dom/client";
+import { stallInProgress } from "./smoke-stream-pacing-stall.ts";
 import "./src/index.css";
 
 /**
@@ -195,12 +196,18 @@ function Harness(): ReactElement {
           }
           state.paintedChars = painted;
           lastGrowthAt = now;
-        } else if (state.streamEndedAtMs === null) {
+        } else {
           // Measure the stall in progress: a stall closed only by a LATER paint misses a
           // freeze that runs to the end of the stream, whose lost tail can hide inside the
-          // 90% floor. Only while text is still arriving; after the stream ends the settle
-          // check's quiet frames would read as a stall.
-          const stall = now - lastGrowthAt;
+          // 90% floor. stallInProgress caps it at stream end, so a freeze spanning that
+          // moment is still recorded in full while the settle check's own quiet frames are
+          // not counted as one.
+          const stall = stallInProgress(
+            lastGrowthAt,
+            now,
+            state.startedAt,
+            state.streamEndedAtMs,
+          );
           if (stall > state.longestStallMs) {
             state.longestStallMs = stall;
           }

studio/frontend/smoke-stream-pacing-stall.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// The stall rule for smoke-stream-pacing-main.tsx, kept here so it can be tested without
+// importing the harness entry, which mounts React into the DOM on import.
+
+/**
+ * How long the bubble has gone without growing, for a stall that no later paint has closed.
+ *
+ * The subtlety is what the interval is measured UP TO. While text is still arriving that is
+ * simply `now`. Once the stream has ended it is the moment it ended, for two opposite reasons
+ * that both point the same way:
+ *
+ * - a freeze that spans the end of the stream blocks the frame loop across it, so the first
+ *   frame afterwards already observes an ended stream. Refusing to measure once the stream has
+ *   ended would skip that whole interval and report no freeze at all, which is the one shape
+ *   this number exists to catch. The lost tail can hide inside the 90% workload floor.
+ * - measuring up to `now` after the stream has ended would count the quiet frames the settle
+ *   check itself needs, so every healthy run would report a stall the length of the settle
+ *   window.
+ *
+ * Capping at stream end satisfies both: the frozen interval is recorded in full, and it stops
+ * growing once there is no more text to be waiting for. Repeat calls return the same value, so
+ * calling this on every frame after the stream ends is idempotent.
+ */
+export function stallInProgress(
+  lastGrowthAt: number,
+  now: number,
+  startedAt: number,
+  streamEndedAtMs: number | null,
+): number {
+  const until = streamEndedAtMs === null ? now : startedAt + streamEndedAtMs;
+  const stall = until - lastGrowthAt;
+  return stall > 0 ? stall : 0;
+}

studio/frontend/tests/stream-pacing-stall.test.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+// The stall rule behind the stream-pacing smoke's longestStallMs, which is the budget that
+// catches the freeze class #7892 and #8845 fixed. A stall the harness fails to record is a
+// harness that passes on a frozen renderer, so the interesting cases here are the ones where
+// no later paint ever arrives to close the stall.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { stallInProgress } from "../smoke-stream-pacing-stall.ts";
+
+const STARTED_AT = 1_000;
+
+test("while text is still arriving, the stall runs to now", () => {
+  assert.equal(stallInProgress(2_000, 3_500, STARTED_AT, null), 1_500);
+});
+
+test("a freeze spanning the end of the stream is still recorded in full", () => {
+  // The regression this exists for. The frame loop is blocked across the moment the stream
+  // ends, so the first frame afterwards (now = 9_000) already sees a non-null streamEndedAtMs.
+  // Measuring only while the stream is live would skip the whole interval and report nothing,
+  // and the missing tail can hide inside the harness's 90% workload floor.
+  const streamEndedAtMs = 4_000; // absolute 5_000
+  assert.equal(stallInProgress(1_500, 9_000, STARTED_AT, streamEndedAtMs), 3_500);
+});
+
+test("after the stream ends the stall stops growing with the settle window", () => {
+  // The settle check needs 30 quiet frames by design. Measuring to now would count them, so
+  // every healthy run would report a stall the length of its own settle window.
+  const streamEndedAtMs = 4_000; // absolute 5_000
+  const atEnd = stallInProgress(4_800, 5_000, STARTED_AT, streamEndedAtMs);
+  const muchLater = stallInProgress(4_800, 60_000, STARTED_AT, streamEndedAtMs);
+  assert.equal(atEnd, 200);
+  assert.equal(muchLater, 200, "quiet frames after the stream ended are not a stall");
+});
+
+test("it is idempotent once the stream has ended", () => {
+  const first = stallInProgress(2_000, 6_000, STARTED_AT, 4_000);
+  const second = stallInProgress(2_000, 30_000, STARTED_AT, 4_000);
+  assert.equal(first, second);
+});
+
+test("growth after the stream ended is not a negative stall", () => {
+  // lastGrowthAt can sit past the stream end when the tail paints late, which would make the
+  // capped interval negative. Report no stall rather than a negative one.
+  assert.equal(stallInProgress(8_000, 9_000, STARTED_AT, 4_000), 0);
+});