@agent-native/core-corpus 0.202.0-nightly-20261006153106 → 0.202.0

package/corpus/README.md

@@ -32,4 +32,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core-corpus/corpu
 
 ## Generated Counts
 
-- template files: 11232
+- template files: 11246

package/corpus/templates/analytics/.agents/skills/session-replay/SKILL.md

@@ -204,10 +204,11 @@ agent answers about browser recordings in the Analytics template.
   read. Change weights only in `SESSION_FRICTION_WEIGHTS`.
 - Every friction surface is behind the Sessions triage Lab, in the UI and in
   `list-session-recordings`, `list-session-friction`, `view-screen`, and
-  `get-session-replay-summary`; a 403 names what the Lab gates. With the Lab off, Sessions looks and behaves exactly as before;
-  ingest still records friction. A link with Lab filters waits up to 5
-  seconds for the Lab state; one that fails or hangs says so with a retry
-  and never reads as the Lab being off.
+  `get-session-replay-summary`; a 403 names what the Lab gates
+  (`assertSessionsTriageLabEnabled` takes every feature the request used).
+  With the Lab off, Sessions looks and behaves exactly as before; ingest
+  still records friction. Waiting on the Lab state is shared with the speed
+  filter; see "Performance In Sessions".
 - Without a friction filter or sort, the list loads without friction and its
   rows read friction from `list-session-friction`, one page of ids at most,
   through the recordings' access filter. A failed friction read then leaves
@@ -226,6 +227,85 @@ agent answers about browser recordings in the Analytics template.
   `truncated`, and `fullPageAction` reads the whole page. Keep it that way
   when adding per-row fields: a bigger row means fewer rows, not a lost page.
 
+## Performance In Sessions
+
+- Core's tracker sends one `web_vitals` event per page view (`route`,
+  `navigation_type`, and whichever of `ttfb_ms`, `lcp_ms`, `inp_ms`, `cls` were
+  measured; an unmeasured metric is absent, never 0) and an
+  `agent-native.vitals` replay marker with the same numbers. `action.response`
+  carries the `route` its request started on. `route` is a React Router
+  template such as `/sessions/:id`; when no manifest route matches it is
+  omitted, never a raw path, which can hold slugs and emails.
+- Requests under `SLOW_REQUEST_THRESHOLD_MS` (`shared/slow-request.ts`, 1 s)
+  are sampled at 10% with `sample_weight: 10`; slow, failed, and 4xx responses
+  always send with weight 1, so slow-request counts are exact. Use that
+  constant for every "slow request" rule. Requests made while the page was
+  hidden or cancelled are not counted. Slow requests (the app's own actions,
+  1 s, counted from events) are not friction's stalled requests (any captured
+  replay request, `STALLED_REQUEST_THRESHOLD_MS`, 3 s): keep their names,
+  fields, columns, and copy apart, and never show one number under the
+  other's label.
+- Ingest strips NUL and replaces lone surrogates in `route`, `app`, and the
+  session id before hashing, as Postgres would store them; otherwise two
+  values that store alike collide in one upsert and fail the batch.
+  Measurements above `performanceCeiling` (the open top bucket's floor: 64 s,
+  CLS 5) are capped there rather than dropped, and `sample_weight` at 10,000.
+  A session value at the ceiling is a floor: summaries list it in `atLeast`
+  and the row hint shows it with ≥.
+- `recordSessionPerformance` keeps each session's worst vitals and its slow
+  requests in `analytics_session_performance`, inside the ingest transaction
+  under a savepoint, with the same gap and coverage rules as the event index.
+  `recordRoutePerformance` adds weights to fixed histogram buckets in
+  `analytics_route_performance_daily` after commit, in its own short
+  transaction. A failed write records a gap: `session_id = ''` marks a
+  route day, read as `incompleteDates`; a session id marks that session,
+  read as `performance.incomplete` and kept by `slow: any` only, since
+  missing data cannot rule it out; `vitals` and `requests` need a measured
+  slow value. The slow filter correlates on each recording's own tenant. As
+  with event friction, a share grants the recording, not its tenant's
+  events: a recording shared from another tenant has no speed summary (null)
+  and never matches a slow filter. A summary's `slowRequests` is null when the session made no
+  measured request. A null summary is a session never measured: its row says
+  "Speed not measured", and a slow match or a range from before coverage
+  shows when speed coverage began, so it never reads as fast. On
+  `list-session-recordings`, `slow` and `includePerformance` always return
+  the paginated shape with `performanceCoverageStartedAt`, as friction does.
+  Bucket edges are positional, so changing them needs a new
+  `PERFORMANCE_HISTOGRAM_VERSION`.
+- Percentiles interpolate inside one bucket. Past the first bucket each edge
+  is at most 28% above the last, so they are within about 28% of the exact
+  value; in the first bucket, within 1 ms (CLS 0.001). Keep that step when
+  adding edges, and keep every rating threshold an edge. A value in the open
+  top bucket is reported as `atLeast`.
+  A metric with no samples is null: no data, never fast. Before the migration
+  creates `analytics_performance_coverage`, ingest stores events without these
+  aggregates and warns, the slow filter matches nothing, and reads report no
+  coverage.
+- The replay's slow-request markers come from the `agent-native.slow_request`
+  events core records beside each slow `action.response` someone waited for,
+  with that event's own duration, status, and outcome. Core and the timeline
+  both apply the count's rule (`isWaitedActionResponse`, from core), so a
+  marker matches exactly what the row counts and background requests never
+  spend the replay's marker budget. Never derive them from replay network events: those stop timing at
+  the response headers. Replays from clients without these events show no
+  slow-request markers.
+- `slow` and `includePerformance` on `list-session-recordings`,
+  `list-session-performance`, `list-route-performance`, the replay's vitals
+  and slow-request markers, and `performance` on `get-session-replay-summary`
+  exist only while the Sessions triage Lab is on.
+- Lab state never holds up the base list. The page waits for it only when the
+  URL carries Lab-only conditions (did/didn't events, friction signals or
+  sorts, `slow`), with one wait for all of them, and for at most 5 s; a
+  failed or hung read lists sessions without them and says so once, with a
+  retry, rather than telling the user to turn on a Lab that may be on.
+  Row speed hints load beside the list through `list-session-performance`,
+  like row friction, keyed on the visible recording ids; when they fail the
+  page says speed data could not load instead of showing no hints, apart
+  from any friction failure. `view-screen` reads Lab state in its own `try`
+  and reads row friction and speed hints beside the base list, reporting
+  `labStateError`, `frictionError`, and `performanceError` separately; its
+  `fullPageAction` asks for both.
+
 ## Agent Diagnostics Surface
 
 - `buildSessionReplayAgentContext` includes a `diagnostics` section: up to 50
@@ -233,7 +313,9 @@ agent answers about browser recordings in the Analytics template.
   and truncated flags. Agent-context instructions steer agents to diagnostics
   as the primary debugging signal.
 - The agent timeline includes `console-error` / `network-error` markers; error
-  markers are kept preferentially under the 200-marker cap.
+  markers are kept preferentially under the 200-marker cap. App event, Web
+  Vitals and slow-request markers belong to the Sessions triage Lab and stay
+  off it (`SESSIONS_TRIAGE_MARKER_TAGS`); add any new Lab marker tag there.
 - `apis.diagnostics` advertises the fuller bounded list:
   `GET /api/session-replay/agent-diagnostics.json?id=<recordingId>&agent_access=<token>&kind=console|network|all&level=<level>&limit=<n>&offset=<n>&fromMs=<n>&toMs=<n>`
   (limit defaults to 200, max 500). It uses the same recording-scoped
@@ -295,7 +377,7 @@ agent answers about browser recordings in the Analytics template.
   widths >= 3,000px. The 2026-07 "ultra-wide replay" bugs (stages rendered
   3,000–9,500px wide, frozen/teleporting cursors, giant icons) were caused
   entirely by demo mode's fetch interceptor: its number redactor faked any
-  integer >= 1000 inside raw replay JSON at *view* time, corrupting Meta /
+  integer >= 1000 inside raw replay JSON at _view_ time, corrupting Meta /
   ViewportResize widths, pointer x/y coordinates, and numeric values inside
   `_cssText` and SVG attributes before rrweb ever saw the payload (heights
   below 1000 stayed real, which is why the symptom looked like a viewport

package/corpus/templates/analytics/AGENTS.md

@@ -89,7 +89,7 @@ certified ones); label figures "Unverified" when no live query ran.
   signals, visitor type, and email domain. Use `paginated: true` for sorted
   pages with a real total and app counts; the default returns an array.
 - With the Sessions triage Lab on, `didEvents` / `didNotEvents` filter by
-  tracked events. Get real names and session counts from
+  tracked events and `slow` by speed. Get real names and session counts from
   `list-session-event-names`, and event health from `list-event-catalog`. Both
   read Analytics' own index, which covers sessions only from its coverage
   start. Never query BigQuery for these views.
@@ -98,7 +98,8 @@ certified ones); label figures "Unverified" when no live query ran.
 
 - `navigation` exposes the current dashboard, analysis, source, chart, and
   selection. `navigate` moves the user between supported Analytics surfaces,
-  `"sessions"`, `"event-catalog"`, `"monitoring"`, and `"agents"`. Use
+  `"sessions"`, `"event-catalog"`, `"performance"`, `"monitoring"`, and
+  `"agents"`. Use
   `view-screen` when the
   active context is unclear.
 - Clicking a panel stages it as a chat context chip and writes `selected-object`

package/corpus/templates/analytics/CHANGELOG.md

@@ -11,6 +11,7 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Fixed
 
+- Session replay agent links stay usable with large event lists and longer agent names.
 - Agent links copied from a dashboard, analysis, or session replay are shorter, so Claude can fetch them without hitting its URL length limit.
 - Analytics keeps workspace access working across apps with different local organization IDs.
 - BigQuery dashboard filters work with values that contain apostrophes or backslashes
@@ -18,6 +19,11 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 ## 2026-10-02
 
+### Added
+
+- With the Sessions triage Lab on, filter sessions by speed, see page vitals and slow requests on replays, and compare p50 and p95 load, interaction, and request times per route
+- With the Sessions triage Lab on, rank and filter sessions by friction signals like dead clicks, error toasts, retry loops, failed actions, and agent failures, and open their Monitoring issues from the list.
+
 ### Improved
 
 - Builder.io setup now explains free credits and the existing-account option.

package/corpus/templates/analytics/actions/get-session-replay-summary.ts

@@ -6,7 +6,10 @@ import {
 import { z } from "zod";
 
 import { listRecordingFriction } from "../server/lib/session-friction.js";
-import { getSessionReplaySummary } from "../server/lib/session-replay.js";
+import {
+  getSessionRecordingPerformance,
+  getSessionReplaySummary,
+} from "../server/lib/session-replay.js";
 import {
   isSessionsTriageLabEnabled,
   sessionsTriageReadFailure,
@@ -22,7 +25,7 @@ function resolveScope() {
 
 export default defineAction({
   description:
-    "Get a scoped summary for one first-party Analytics session replay recording. Does not return raw chunks or storage references. With the Sessions triage Lab on it adds `friction`, the object the replay page's Friction tab shows: score, every signal's count (a null part means not measured, not zero), agent failures grouped by cause, and linked Monitoring error issues (null means the links are unknown, [] means none). A Lab state or friction read that fails returns `labStateError` or `frictionError` instead.",
+    "Get a scoped summary for one first-party Analytics session replay recording. Does not return raw chunks or storage references. With the Sessions triage Lab on it adds `friction`, the object the replay page's Friction tab shows: score, every signal's count (a null part means not measured, not zero), agent failures grouped by cause, and linked Monitoring error issues (null means the links are unknown, [] means none). It also adds `performance`, the recording's speed summary (worst page-view vitals, slowRequests of 1 s or more, maxRequestMs, atLeast, incomplete; null when never measured), and `performanceCoverageStartedAt`. A Lab state, friction, or speed read that fails returns `labStateError`, `frictionError`, or `performanceError` instead.",
   schema: z.object({
     recordingId: z.string().describe("The session_recordings id"),
   }),
@@ -47,18 +50,43 @@ export default defineAction({
       };
     }
     if (!labEnabled) return summary;
-    try {
-      const friction = (await listRecordingFriction(scope, [summary.id]))[
-        summary.id
-      ];
-      return friction
-        ? { ...summary, friction }
-        : { ...summary, frictionError: "Friction read skipped this recording" };
-    } catch (error) {
-      return {
-        ...summary,
-        frictionError: sessionsTriageReadFailure("friction", LOG_PREFIX, error),
-      };
-    }
+    const [friction, speed] = await Promise.allSettled([
+      listRecordingFriction(scope, [summary.id]),
+      getSessionRecordingPerformance(scope, [summary.id]),
+    ]);
+    const recordingFriction =
+      friction.status === "fulfilled" ? friction.value[summary.id] : undefined;
+    const recordingSpeed =
+      speed.status === "fulfilled"
+        ? speed.value.performance[summary.id]
+        : undefined;
+    return {
+      ...summary,
+      ...(friction.status === "rejected"
+        ? {
+            frictionError: sessionsTriageReadFailure(
+              "friction",
+              LOG_PREFIX,
+              friction.reason,
+            ),
+          }
+        : recordingFriction
+          ? { friction: recordingFriction }
+          : { frictionError: "Friction read skipped this recording" }),
+      ...(speed.status === "rejected"
+        ? {
+            performanceError: sessionsTriageReadFailure(
+              "speed",
+              LOG_PREFIX,
+              speed.reason,
+            ),
+          }
+        : recordingSpeed !== undefined
+          ? {
+              performance: recordingSpeed,
+              performanceCoverageStartedAt: speed.value.coverageStartedAt,
+            }
+          : { performanceError: "Speed read skipped this recording" }),
+    };
   },
 });

package/corpus/templates/analytics/actions/list-route-performance.ts

@@ -0,0 +1,53 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import {
+  listRoutePerformance,
+  ROUTE_PERFORMANCE_MAX_LIMIT,
+} from "../server/lib/session-performance.js";
+import { assertSessionsTriageLabEnabled } from "../server/lib/sessions-triage-lab.js";
+import { sessionEventBoundSchema } from "../shared/session-events.js";
+
+export default defineAction({
+  description:
+    "List page routes (React Router templates such as /sessions/:id) with p50 and p95 of TTFB, LCP, INP, CLS, and action request duration, plus the count of requests of 1 s or more, from Analytics' own daily histograms. Percentiles are interpolated inside fixed buckets (within about 28% of the exact value; under 1 ms, or CLS 0.001, within that much); request counts are scaled by their sampling. A metric with no samples is null, which means no data, not fast. Returns the most-measured routes first (vitals reported plus requests timed), apps (every app with measured routes in the range, whatever the app filter), coverageStartedAt (null when nothing is measured yet), and incompleteDates whose aggregates missed some events. Ranges cover whole UTC days, at most 90. Requires the Sessions triage Lab.",
+  schema: z.object({
+    from: sessionEventBoundSchema
+      .optional()
+      .describe(
+        "Inclusive first UTC day as an ISO date or a timestamp with an offset; defaults to 6 days before to",
+      ),
+    to: sessionEventBoundSchema
+      .optional()
+      .describe(
+        "Inclusive last UTC day as an ISO date or a timestamp with an offset; defaults to today",
+      ),
+    app: z.string().optional().describe("Optional app filter"),
+    limit: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(ROUTE_PERFORMANCE_MAX_LIMIT)
+      .optional()
+      .describe("Most routes to return, most-measured first; defaults to 50"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async (args) => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) {
+      fail("no authenticated user", {
+        errorCode: "unauthenticated",
+        statusCode: 401,
+      });
+    }
+    const orgId = getRequestOrgId() || null;
+    await assertSessionsTriageLabEnabled(userEmail, orgId, ["speed"]);
+    return listRoutePerformance({ userEmail, orgId }, args);
+  },
+});

package/corpus/templates/analytics/actions/list-session-friction.ts

@@ -32,7 +32,7 @@ export default defineAction({
       });
     }
     const orgId = getRequestOrgId() || null;
-    await assertSessionsTriageLabEnabled(userEmail, orgId, "friction");
+    await assertSessionsTriageLabEnabled(userEmail, orgId, ["friction"]);
     return {
       friction: await listRecordingFriction({ userEmail, orgId }, recordingIds),
     };

package/corpus/templates/analytics/actions/list-session-performance.ts

@@ -0,0 +1,37 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getSessionRecordingPerformance } from "../server/lib/session-replay.js";
+import { assertSessionsTriageLabEnabled } from "../server/lib/sessions-triage-lab.js";
+import { SESSION_PAGE_SIZE } from "../shared/session-page.js";
+
+export default defineAction({
+  description:
+    "Speed summaries for specific session recordings, such as the rows of one list page: each recording's worst measured page-view vitals (ttfbMs, lcpMs, inpMs, cls), slowRequests (requests of 1 s or more; null when no request was measured), maxRequestMs, atLeast (fields that hit the measurement ceiling, so each is a floor), and incomplete (some measurements failed to save, so it may be slower). A recording that was never measured maps to null; ids you cannot read are absent. Also returns coverageStartedAt. Requires the Sessions triage Lab.",
+  schema: z.object({
+    recordingIds: z
+      .array(z.string().min(1).max(200))
+      .max(SESSION_PAGE_SIZE)
+      .default([])
+      .describe(`Recording ids, at most ${SESSION_PAGE_SIZE}: one list page`),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({ recordingIds }) => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) {
+      fail("no authenticated user", {
+        errorCode: "unauthenticated",
+        statusCode: 401,
+      });
+    }
+    const orgId = getRequestOrgId() || null;
+    await assertSessionsTriageLabEnabled(userEmail, orgId, ["speed"]);
+    return getSessionRecordingPerformance({ userEmail, orgId }, recordingIds);
+  },
+});

package/corpus/templates/analytics/actions/list-session-recordings.ts

@@ -11,13 +11,17 @@ import {
   listSessionRecordingsPage,
   type SessionRecordingSummary,
 } from "../server/lib/session-replay.js";
-import { assertSessionsTriageLabEnabled } from "../server/lib/sessions-triage-lab.js";
+import {
+  assertSessionsTriageLabEnabled,
+  type SessionsTriageLabFeature,
+} from "../server/lib/sessions-triage-lab.js";
 import { MAX_SESSION_EVENT_CONDITIONS } from "../shared/session-events.js";
 import {
   isSessionFrictionSort,
   SESSION_FRICTION_SIGNALS,
   SESSION_FRICTION_SORTS,
 } from "../shared/session-friction.js";
+import { SLOW_SESSION_FILTERS } from "../shared/session-performance.js";
 
 function resolveScope() {
   const userEmail = getRequestUserEmail();
@@ -111,7 +115,7 @@ export default defineAction({
       .boolean()
       .optional()
       .describe(
-        "Return recordings, total count, and app counts rather than the legacy recordings array. Friction filters and sorts always return this shape.",
+        "Return recordings, total count, and app counts rather than the legacy recordings array. Friction filters and sorts, `slow`, and `includePerformance` always return this shape.",
       ),
     status: z.enum(["active", "completed"]).optional(),
     didEvents: z
@@ -141,6 +145,18 @@ export default defineAction({
       .describe(
         "Add each recording's friction: score, signal counts, top signals, failed actions and agent failures grouped by cause, and linked Monitoring error issues. A null part means it was not measured, not zero: `thumbs_down`, `cancelled_runs`, and `quick_backs` can be null alone, and `errorIssues` null means the links are unknown while [] means no issues. Requires the Sessions triage Lab.",
       ),
+    slow: z
+      .enum(SLOW_SESSION_FILTERS)
+      .optional()
+      .describe(
+        "Only slow sessions: vitals = a page view with a poor Core Web Vital (LCP > 4 s, INP > 500 ms, CLS > 0.25, or TTFB > 1.8 s); requests = an action request of 1 s or more (not the 3 s `stalled_requests` friction signal); any = either, plus sessions whose measurements failed to save, since missing data cannot rule them out. Sessions without measurements never match. Requires the Sessions triage Lab.",
+      ),
+    includePerformance: z
+      .boolean()
+      .optional()
+      .describe(
+        "Attach each recording's speed summary as performance, plus performanceCoverageStartedAt: worst measured page-view vitals, slowRequests (null when no request was measured), maxRequestMs, atLeast (fields that hit the measurement ceiling, so each is a floor), and incomplete (some measurements failed to save, so it may be slower). performance is null when never measured. Requires the Sessions triage Lab.",
+      ),
     limit: z.coerce.number().int().min(1).max(100).optional().default(50),
   }),
   http: { method: "GET" },
@@ -150,28 +166,28 @@ export default defineAction({
   grounding: true,
   run: async (args) => {
     const scope = resolveScope();
-    const usesEvents = Boolean(
-      args.didEvents?.length || args.didNotEvents?.length,
-    );
     const frictionApplied = Boolean(
       args.frictionSignals?.length || isSessionFrictionSort(args.sort),
     );
-    const usesFriction = frictionApplied || Boolean(args.includeFriction);
-    if (usesEvents || usesFriction) {
+    const labFeatures: SessionsTriageLabFeature[] = [];
+    if (args.didEvents?.length || args.didNotEvents?.length) {
+      labFeatures.push("events");
+    }
+    if (frictionApplied || args.includeFriction) labFeatures.push("friction");
+    if (args.slow || args.includePerformance) labFeatures.push("speed");
+    if (labFeatures.length) {
       await assertSessionsTriageLabEnabled(
         scope.userEmail,
         scope.orgId,
-        usesEvents && usesFriction
-          ? "events and friction"
-          : usesEvents
-            ? "events"
-            : "friction",
+        labFeatures,
       );
     }
     const { includeFriction, ...filters } = args;
-    // The legacy array has no room for frictionCoverageStartedAt, and without
-    // it an empty friction match cannot be told apart from "not measured".
-    if (!args.paginated && !frictionApplied) {
+    // The legacy array has no room for the friction or speed coverage start,
+    // and without it an empty match cannot be told apart from "not measured".
+    const coverageNeeded =
+      frictionApplied || Boolean(args.slow || args.includePerformance);
+    if (!args.paginated && !coverageNeeded) {
       const recordings = await listSessionRecordings(scope, filters);
       return includeFriction ? withFriction(scope, recordings) : recordings;
     }

package/corpus/templates/analytics/actions/navigate.ts

@@ -49,7 +49,7 @@ export default defineAction({
       .string()
       .optional()
       .describe(
-        "View to navigate to (ask, adhoc, analyses, extensions, sessions, event-catalog, monitoring, agents, data-dictionary, data-sources, settings). event-catalog requires the Sessions triage Lab.",
+        "View to navigate to (ask, adhoc, analyses, extensions, sessions, event-catalog, performance, monitoring, agents, data-dictionary, data-sources, settings). event-catalog and performance (per-route Web Vitals and request percentiles) require the Sessions triage Lab.",
       ),
     dashboardId: z
       .string()

package/corpus/templates/analytics/actions/view-screen.ts

@@ -12,6 +12,7 @@ import { getErrorIssue, listErrorIssues } from "../server/lib/error-capture.js";
 import { listAnalyticsPublicKeys } from "../server/lib/first-party-analytics.js";
 import { getSessionFrictionDetails } from "../server/lib/session-friction.js";
 import {
+  getSessionRecordingPerformance,
   getSessionReplaySummary,
   listSessionRecordingsPage,
   replayRangeToIso,
@@ -39,6 +40,11 @@ import {
   SESSION_FRICTION_SIGNAL_PARAM,
 } from "../shared/session-friction";
 import { readSessionPage, SESSION_PAGE_SIZE } from "../shared/session-page";
+import {
+  isSlowSessionFilter,
+  readRoutePerformanceRange,
+  routePerformanceRangeBounds,
+} from "../shared/session-performance";
 
 const SESSION_FILTER_KEYS = new Set([
   "range",
@@ -303,9 +309,13 @@ export default defineAction({
             const urlFrictionSort = isSessionFrictionSort(params.sort)
               ? params.sort
               : null;
+            const urlSlow = isSlowSessionFilter(params.slow)
+              ? params.slow
+              : undefined;
             // Match the page: event conditions, friction filters and sorts,
-            // and row friction apply only with the Lab on. A failed Lab read
-            // is reported, and the base list is still read without them.
+            // the slow filter, and row friction and speed hints apply only
+            // with the Lab on. A failed Lab read is reported, and the base
+            // list is still read without them.
             let triageLabEnabled = false;
             let labStateError: string | undefined;
             try {
@@ -331,30 +341,54 @@ export default defineAction({
                 filters.frictionSignals = urlFrictionSignals;
               }
               if (urlFrictionSort) filters.sort = urlFrictionSort;
+              if (urlSlow) filters.slow = urlSlow;
             }
             const result = await listSessionRecordingsPage(scope, {
               ...filters,
               limit: SESSION_EXCERPT_SIZE,
             });
             screen.sessionReplays = result.recordings;
+            // Row friction and speed hints load beside the list, as on the
+            // page, so either one failing leaves the list and is reported
+            // on its own.
             let frictionError: string | undefined;
+            let performanceError: string | undefined;
+            let performanceCoverageStartedAt: string | null | undefined;
             if (triageLabEnabled) {
-              try {
-                const friction = await getSessionFrictionDetails(
+              const [friction, speed] = await Promise.allSettled([
+                getSessionFrictionDetails(scope, result.recordings),
+                getSessionRecordingPerformance(
                   scope,
-                  result.recordings,
-                );
-                screen.sessionReplays = result.recordings.map((recording) => ({
-                  ...recording,
-                  friction: friction.get(recording.id),
-                }));
-              } catch (error) {
+                  result.recordings.map((recording) => recording.id),
+                ),
+              ]);
+              if (friction.status === "rejected") {
                 frictionError = sessionsTriageReadFailure(
                   "friction",
                   "[view-screen]",
-                  error,
+                  friction.reason,
+                );
+              }
+              if (speed.status === "rejected") {
+                performanceError = sessionsTriageReadFailure(
+                  "speed",
+                  "[view-screen]",
+                  speed.reason,
                 );
+                performanceCoverageStartedAt =
+                  result.performanceCoverageStartedAt;
+              } else {
+                performanceCoverageStartedAt = speed.value.coverageStartedAt;
               }
+              screen.sessionReplays = result.recordings.map((recording) => ({
+                ...recording,
+                ...(friction.status === "fulfilled"
+                  ? { friction: friction.value.get(recording.id) }
+                  : {}),
+                ...(speed.status === "fulfilled"
+                  ? { performance: speed.value.performance[recording.id] }
+                  : {}),
+              }));
             }
             // The URL's sort and Lab conditions are not what was applied
             // while the Lab is off, so echo the list's own filters.
@@ -372,6 +406,7 @@ export default defineAction({
               activeFilters[SESSION_FRICTION_SIGNAL_PARAM] =
                 filters.frictionSignals;
             }
+            if (filters.slow) activeFilters.slow = filters.slow;
             if (Object.keys(activeFilters).length > 0) {
               screen.activeFilters = activeFilters;
             }
@@ -388,11 +423,15 @@ export default defineAction({
               excerptLimit: SESSION_EXCERPT_SIZE,
               ...(labStateError ? { labStateError } : {}),
               ...(frictionError ? { frictionError } : {}),
+              ...(performanceError ? { performanceError } : {}),
               ...(result.frictionCoverageStartedAt !== undefined
                 ? {
                     frictionCoverageStartedAt: result.frictionCoverageStartedAt,
                   }
                 : {}),
+              ...(performanceCoverageStartedAt !== undefined
+                ? { performanceCoverageStartedAt }
+                : {}),
               ...(urlHasEventConditions && !triageLabEnabled
                 ? { eventConditionsNotApplied: urlEventConditions }
                 : {}),
@@ -405,6 +444,9 @@ export default defineAction({
                     },
                   }
                 : {}),
+              ...(urlSlow && !triageLabEnabled
+                ? { slowFilterNotApplied: urlSlow }
+                : {}),
               truncated:
                 result.recordings.length <
                 Math.min(SESSION_PAGE_SIZE, Math.max(0, result.total - offset)),
@@ -413,7 +455,9 @@ export default defineAction({
                 args: {
                   paginated: true,
                   ...filters,
-                  ...(triageLabEnabled ? { includeFriction: true } : {}),
+                  ...(triageLabEnabled
+                    ? { includeFriction: true, includePerformance: true }
+                    : {}),
                   limit: SESSION_PAGE_SIZE,
                 },
               },
@@ -447,6 +491,28 @@ export default defineAction({
             },
           }
         : { labEnabled: false };
+    } else if (nav?.view === "performance") {
+      screen.page = "route-performance";
+      const email = getRequestUserEmail();
+      const orgId = getRequestOrgId() || null;
+      const labEnabled = email
+        ? await isSessionsTriageLabEnabled(email, orgId)
+        : false;
+      const params = url?.searchParams ?? {};
+      const range = readRoutePerformanceRange(params.range);
+      screen.routePerformance = labEnabled
+        ? {
+            range,
+            app: params.app || null,
+            fullPageAction: {
+              name: "list-route-performance",
+              args: {
+                ...routePerformanceRangeBounds(range),
+                ...(params.app ? { app: params.app } : {}),
+              },
+            },
+          }
+        : { labEnabled: false };
     } else if (nav?.view === "monitoring") {
       screen.page = "monitoring";
       const monitoringView =

package/corpus/templates/analytics/app/components/layout/Layout.tsx

@@ -39,6 +39,7 @@ import { TAB_ID } from "@/lib/tab-id";
 import { AgentCompletionSound } from "../AgentCompletionSound";
 import { Header } from "./Header";
 import { HeaderActionsProvider } from "./HeaderActions";
+import { isSessionReplayRoute } from "./layout-route-policy";
 import { MobileNav } from "./MobileNav";
 import { Sidebar } from "./Sidebar";
 
@@ -160,7 +161,7 @@ function InteractiveLayout({ children }: LayoutProps) {
   const isExtensionsRoute =
     location.pathname === "/extensions" ||
     location.pathname.startsWith("/extensions/");
-  const isSessionDetailRoute = /^\/sessions\/[^/]+/.test(location.pathname);
+  const isSessionDetailRoute = isSessionReplayRoute(location.pathname);
   const isMonitoringRoute =
     location.pathname === "/monitoring" ||
     location.pathname.startsWith("/monitoring/");