@agent-native/core 0.98.3 → 0.98.5

package/corpus/templates/analytics/app/pages/sessions/SessionDetailPage.tsx

@@ -166,11 +166,6 @@ type ReplayViewportChange = ReplayViewportDimensions & {
 
 const DEFAULT_PLAYER_WIDTH = 1024;
 const DEFAULT_PLAYER_HEIGHT = 640;
-const MALFORMED_REPLAY_MIN_WIDTH = 4000;
-const MALFORMED_REPLAY_MIN_ASPECT_RATIO = 4;
-const MIN_REPLAY_DISPLAY_DIMENSION = 240;
-const RECOVERED_REPLAY_DISPLAY_ASPECT_RATIO =
-  DEFAULT_PLAYER_WIDTH / DEFAULT_PLAYER_HEIGHT;
 const DEFAULT_SPEED = 2;
 const SPEED_OPTIONS = [0.5, 1, 2, 4, 8];
 const SKIP_STEP_MS = 5000;
@@ -186,10 +181,14 @@ const MIN_STAGE_HEIGHT_PX = 240;
 const SCRUBBER_MARKER_LIMIT = 500;
 const TIMELINE_MARKER_LIMIT = 300;
 const TIMELINE_FOLLOW_PAUSE_MS = 4000;
-/** Toast/snackbar noise only — keep insertStyleRules minimal like builder-internal. */
-const SUPPRESS_OVERLAYS_CSS = [
-  "[data-radix-popper-content-wrapper], .Toastify, [class*='toast'], [class*='Toast'], [class*='Snackbar'] { display: none !important; }",
-];
+const REPLAY_CLOCK_UPDATE_INTERVAL_MS = 100;
+/**
+ * Keep captured overlays intact. Toasts and snackbars are product feedback,
+ * not recorder chrome, and can be essential to understanding the session.
+ * The recorder does not inject notification UI into the recorded document, so
+ * blanket selectors (including Sonner's data attributes) are not justified.
+ */
+export const REPLAY_OVERLAY_STYLE_RULES: string[] = [];
 type ReplayConsoleDiagnostics = ReturnType<
   typeof extractReplayDiagnostics
 >["console"];
@@ -235,11 +234,13 @@ const RRWEB_EVENT_TYPE = {
 
 const INCREMENTAL_SOURCE = {
   Mutation: 0,
+  MouseMove: 1,
   MouseInteraction: 2,
   Scroll: 3,
   ViewportResize: 4,
   Input: 5,
   TouchMove: 6,
+  Drag: 12,
 } as const;
 
 const MOUSE_INTERACTION = {
@@ -480,6 +481,7 @@ function ReplayPlayer({
   const stageRootRef = useRef<HTMLDivElement>(null);
   const replayerRef = useRef<any>(null);
   const rafRef = useRef<number | null>(null);
+  const lastClockUpdateAtRef = useRef<number | null>(null);
   const [status, setStatus] = useState<ReplayPlayerStatus>("idle");
   const [error, setError] = useState<string | null>(null);
   const [playing, setPlaying] = useState(false);
@@ -497,7 +499,7 @@ function ReplayPlayer({
   } | null>(null);
   const [fitScale, setFitScale] = useState(1);
   const initialDims = useMemo(
-    () => replayInitialDisplayDimensions(events),
+    () => replayInitialViewportDimensions(events),
     [events],
   );
   const viewportTimeline = useMemo(
@@ -519,16 +521,14 @@ function ReplayPlayer({
   const scrubbingRef = useRef(false);
   const scrubResumePlayingRef = useRef(false);
 
-  // IMPORTANT — DO NOT REMOVE THIS LEGACY VIEWPORT CORRECTION.
-  // Some stored sessions contain impossible 4,000–7,500px-wide Meta/resize
-  // values even though the browser was a normal desktop viewport. Rendering
-  // those raw values collapses the replay into a tiny horizontal ribbon. Keep
-  // normal recordings exact—including 32:9 and mobile portrait. Recover only
-  // widths >=4,000px with aspect >4:1 to the standard 16:10 viewport. The same
-  // dimensions are applied to rrweb's iframe so CSS breakpoints/camera agree.
-  const displayDims = clampReplayDisplayDimensions(streamedDims ?? initialDims);
-  const playerWidth = displayDims?.width ?? DEFAULT_PLAYER_WIDTH;
-  const playerHeight = displayDims?.height ?? DEFAULT_PLAYER_HEIGHT;
+  // Fall back to the default player size only when the viewport is unknown;
+  // otherwise render the raw recorded dimensions untouched. See the Replayer
+  // construction below for why "recovery" heuristics were removed here.
+  const displayDims = resolveReplayDisplayDimensions(
+    streamedDims ?? initialDims,
+  );
+  const playerWidth = displayDims.width;
+  const playerHeight = displayDims.height;
   const skipRanges = useMemo(() => buildIdleSkipRanges(events), [events]);
   const skipRangesRef = useLiveRef(skipRanges);
   const skipInactiveRef = useLiveRef(skipInactive);
@@ -624,10 +624,16 @@ function ReplayPlayer({
 
   const updateTime = useCallback(
     (next: number) => {
+      if (!Number.isFinite(next) || next === currentTimeRef.current) return;
+      // Keep the live value in sync before React commits. The animation clock
+      // can run again while React is still processing the previous render;
+      // relying on useLiveRef's effect here republishes the same value and can
+      // create a nested update loop in development.
+      currentTimeRef.current = next;
       setCurrentTime(next);
       onTimeUpdate(next);
     },
-    [onTimeUpdate],
+    [currentTimeRef, onTimeUpdate],
   );
 
   const seek = useCallback(
@@ -652,18 +658,16 @@ function ReplayPlayer({
         clamped,
       );
       if (seekDims) {
-        // rrweb 2.1 does not reliably re-emit Resize when seeking backwards.
-        // IMPORTANT: correct both layers together. Correcting only the outer
-        // stage or only rrweb's iframe recreates the ultra-wide/clipped bug.
-        const correctedSeekDims = clampReplayDisplayDimensions(seekDims);
+        // rrweb 2.1 does not reliably re-emit its resize event when seeking
+        // backwards, so mirror the raw viewport-timeline lookup onto both
+        // rrweb's iframe and the outer stage state to keep them in sync.
         const currentDims = streamedDimsRef.current;
         if (
-          correctedSeekDims &&
-          (currentDims?.width !== correctedSeekDims.width ||
-            currentDims?.height !== correctedSeekDims.height)
+          currentDims?.width !== seekDims.width ||
+          currentDims?.height !== seekDims.height
         ) {
-          replayer.handleResize?.(correctedSeekDims);
-          setStreamedDims(correctedSeekDims);
+          replayer.handleResize?.(seekDims);
+          setStreamedDims(seekDims);
         }
       }
       updateTime(clamped);
@@ -709,27 +713,17 @@ function ReplayPlayer({
     let localReplayer: any = null;
 
     async function loadReplay() {
-      // Wait for the full recording before creating the Replayer. Progressive
-      // chunk publishes used to rebuild the player on every append, which
-      // reset the clock, disabled the scrubber, and desynced the playhead.
       const replayEvents = eventsRef.current;
+      // Replayer construction remains all-or-nothing. Progressive response
+      // publishes update loading progress only; rebuilding during download
+      // rewinds the player and can desync the scrubber/playhead.
       if (!response.isComplete) {
         setStatus("loading");
         setError(null);
         setPlaying(false);
         return;
       }
-      if (replayEvents.length < 2) {
-        throw new Error(t("sessions.noReplayEvents"));
-      }
-      if (
-        !replayEvents.some(
-          (event) => event.type === RRWEB_EVENT_TYPE.FullSnapshot,
-        )
-      ) {
-        throw new Error(t("sessions.noReplayEvents"));
-      }
-      if (!hasPlayableReplayEvents(replayEvents)) {
+      if (replayEvents.length < 2 || !hasPlayableReplayEvents(replayEvents)) {
         throw new Error(t("sessions.noReplayEvents"));
       }
       setStatus("loading");
@@ -739,35 +733,30 @@ function ReplayPlayer({
       if (cancelled || !stageRootRef.current) return;
 
       stageRootRef.current.innerHTML = "";
-      // Match builder-internal: pass events through untouched and let rrweb own
-      // normal iframe sizing via Meta / ViewportResize. Never rewrite Meta or
-      // force arbitrary iframe dimensions (that mismatches the FullSnapshot DOM
-      // and blanks the stage). The one exception below mirrors the narrowly
-      // detected legacy malformed viewport onto both the iframe and outer stage.
-      const rawInitialDims = replayInitialViewportDimensions(replayEvents);
-      const correctedInitialDims = replayInitialDisplayDimensions(replayEvents);
-      setStreamedDims(correctedInitialDims);
+      // Viewport and pointer events must pass through to rrweb untouched.
+      // The 2026-07 "ultra-wide replay" bugs (e.g. a stored 1,152px-wide
+      // recording rendering as a 4,491px Meta width) were caused by demo
+      // mode's fetch redaction faking numbers >= 1000 in raw replay JSON at
+      // view time, not by malformed stored geometry — fixed in
+      // packages/core/src/demo/fetch-interceptor.ts. Stored recordings were
+      // always sane, so never add viewport "recovery" heuristics here; they
+      // can only corrupt genuine recordings (e.g. a real ultrawide window).
+      setStreamedDims(replayInitialViewportDimensions(replayEvents));
+      // Keep this loosely typed: our internal AnyReplayEvent shape doesn't
+      // exactly match rrweb's declared eventWithTime type.
       localReplayer = new Replayer(replayEvents as any[], {
         root: stageRootRef.current,
         speed: speedRef.current,
         skipInactive: false,
         showWarning: false,
         showDebug: false,
-        triggerFocus: false,
         mouseTail: false,
-        insertStyleRules: SUPPRESS_OVERLAYS_CSS,
+        // Match stock rrweb/builder-internal focus replay. Disabling focus
+        // drops recorded focus-visible state and can leave menus/forms looking
+        // unlike the source page even when the snapshot CSS is correct.
+        triggerFocus: true,
+        insertStyleRules: REPLAY_OVERLAY_STYLE_RULES,
       });
-      // IMPORTANT: rrweb constructs its iframe from the raw initial Meta event.
-      // When that legacy Meta width is malformed, correcting only streamedDims
-      // fixes the outer stage but leaves CSS breakpoints and clicks ultra-wide.
-      // Apply the same correction to rrweb immediately, before first playback.
-      if (
-        correctedInitialDims &&
-        (rawInitialDims?.width !== correctedInitialDims.width ||
-          rawInitialDims?.height !== correctedInitialDims.height)
-      ) {
-        localReplayer.handleResize?.(correctedInitialDims);
-      }
       // rrweb already sandboxes the replay document without script execution.
       // Do not mutate recorded URLs/CSS; suppress viewer-page referrer leakage
       // at the iframe boundary while retaining historical visual resources.
@@ -800,25 +789,17 @@ function ReplayPlayer({
             width: Math.round(dims.width),
             height: Math.round(dims.height),
           };
-          const correctedDims = clampReplayDisplayDimensions(rawDims);
-          if (!correctedDims) return;
-          // rrweb handles the raw resize before notifying us. Override only
-          // impossible legacy geometry so its iframe and our stage stay equal.
-          // DO NOT clamp just one layer; that breaks responsive CSS and clicks.
+          // rrweb owns its iframe geometry from raw Meta/ViewportResize
+          // events. Only mirror the raw dims into React state here, for the
+          // outer stage's fit-to-container scaling.
           const currentDims = streamedDimsRef.current;
           if (
-            currentDims?.width === correctedDims.width &&
-            currentDims?.height === correctedDims.height
+            currentDims?.width === rawDims.width &&
+            currentDims?.height === rawDims.height
           ) {
             return;
           }
-          if (
-            correctedDims.width !== rawDims.width ||
-            correctedDims.height !== rawDims.height
-          ) {
-            localReplayer.handleResize?.(correctedDims);
-          }
-          setStreamedDims(correctedDims);
+          setStreamedDims(rawDims);
         }
       });
       updateTime(startAt);
@@ -851,6 +832,7 @@ function ReplayPlayer({
       try {
         localReplayer?.pause?.();
         localReplayer?.destroy?.();
+        replayerRef.current?.pause?.();
         replayerRef.current?.destroy?.();
       } catch {
         // rrweb cleanup is best-effort across versions.
@@ -858,9 +840,6 @@ function ReplayPlayer({
       replayerRef.current = null;
       if (stageRootRef.current) stageRootRef.current.innerHTML = "";
     };
-    // Key only on isComplete + a stable events identity. Including the events
-    // array reference would rebuild the Replayer when the final publish()
-    // replaces the chunks object even though the event set is unchanged.
   }, [
     currentTimeRef,
     eventsIdentity,
@@ -875,10 +854,11 @@ function ReplayPlayer({
     if (!playing || status !== "ready") {
       if (rafRef.current != null) cancelAnimationFrame(rafRef.current);
       rafRef.current = null;
+      lastClockUpdateAtRef.current = null;
       return;
     }
 
-    const tick = () => {
+    const tick = (frameTime: number) => {
       const replayer = replayerRef.current;
       if (replayer && !scrubbingRef.current) {
         let nextTime = Number(
@@ -901,7 +881,17 @@ function ReplayPlayer({
             }
           }
         }
-        if (Number.isFinite(nextTime)) updateTime(nextTime);
+        if (
+          shouldPublishReplayClockUpdate(
+            lastClockUpdateAtRef.current,
+            frameTime,
+            currentTimeRef.current,
+            nextTime,
+          )
+        ) {
+          lastClockUpdateAtRef.current = frameTime;
+          updateTime(nextTime);
+        }
       }
       rafRef.current = requestAnimationFrame(tick);
     };
@@ -910,6 +900,7 @@ function ReplayPlayer({
     return () => {
       if (rafRef.current != null) cancelAnimationFrame(rafRef.current);
       rafRef.current = null;
+      lastClockUpdateAtRef.current = null;
     };
   }, [
     currentTimeRef,
@@ -995,6 +986,10 @@ function ReplayPlayer({
                 />
                 <button
                   type="button"
+                  // IMPORTANT: Keep the viewer's real OS pointer visible while
+                  // the synthetic rrweb pointer replays underneath it. Hiding
+                  // this during playback makes the page feel broken whenever
+                  // the viewer moves their mouse over the full-stage control.
                   className="absolute inset-0 z-20 cursor-pointer rounded-[inherit] border-0 bg-transparent p-0 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-default"
                   disabled={disabled}
                   aria-label={
@@ -2169,9 +2164,7 @@ export function buildIdleSkipRanges(events: AnyReplayEvent[]): SkipRange[] {
     const timestamp = Number(event.timestamp ?? 0);
     if (!Number.isFinite(timestamp) || timestamp <= 0) continue;
     lastTimestamp = Math.max(lastTimestamp, timestamp);
-    if (isReplayActivityEvent(event)) {
-      interactions.push(timestamp);
-    }
+    interactions.push(...replayActivityTimestamps(event, timestamp));
   }
   interactions.sort((a, b) => a - b);
   const ranges: SkipRange[] = [];
@@ -2194,22 +2187,42 @@ export function buildIdleSkipRanges(events: AnyReplayEvent[]): SkipRange[] {
   return ranges;
 }
 
-function isReplayActivityEvent(event: AnyReplayEvent): boolean {
-  if (event.type === RRWEB_EVENT_TYPE.Meta) return true;
-  if (event.type !== RRWEB_EVENT_TYPE.IncrementalSnapshot) return false;
+function replayActivityTimestamps(
+  event: AnyReplayEvent,
+  timestamp: number,
+): number[] {
+  if (event.type === RRWEB_EVENT_TYPE.Meta) return [timestamp];
+  if (event.type !== RRWEB_EVENT_TYPE.IncrementalSnapshot) return [];
 
   const source = event.data?.source;
+  if (
+    source === INCREMENTAL_SOURCE.MouseMove ||
+    source === INCREMENTAL_SOURCE.TouchMove ||
+    source === INCREMENTAL_SOURCE.Drag
+  ) {
+    const positions = Array.isArray(event.data?.positions)
+      ? event.data.positions
+      : [];
+    // IMPORTANT: rrweb batches pointer positions and schedules each one at
+    // event.timestamp + timeOffset. Treat those exact moments as activity.
+    // Ignoring the batch made Skip inactivity jump across visible movement,
+    // which looked like a frozen cursor even though the recording was intact.
+    return positions.flatMap((position: unknown) => {
+      if (!isRecord(position)) return [];
+      const timeOffset = Number(position.timeOffset ?? 0);
+      return [timestamp + (Number.isFinite(timeOffset) ? timeOffset : 0)];
+    });
+  }
   if (
     source === INCREMENTAL_SOURCE.Input ||
-    source === INCREMENTAL_SOURCE.Scroll ||
-    source === INCREMENTAL_SOURCE.TouchMove
+    source === INCREMENTAL_SOURCE.Scroll
   ) {
-    return true;
+    return [timestamp];
   }
-  if (source !== INCREMENTAL_SOURCE.MouseInteraction) return false;
+  if (source !== INCREMENTAL_SOURCE.MouseInteraction) return [];
 
   const interactionType = event.data?.type;
-  return (
+  return [
     interactionType === MOUSE_INTERACTION.MouseUp ||
     interactionType === MOUSE_INTERACTION.MouseDown ||
     interactionType === MOUSE_INTERACTION.Click ||
@@ -2218,7 +2231,9 @@ function isReplayActivityEvent(event: AnyReplayEvent): boolean {
     interactionType === MOUSE_INTERACTION.Focus ||
     interactionType === MOUSE_INTERACTION.TouchStart ||
     interactionType === MOUSE_INTERACTION.TouchEnd
-  );
+      ? timestamp
+      : null,
+  ].filter((value): value is number => value !== null);
 }
 
 function pushIdleRange(
@@ -2291,14 +2306,6 @@ export function replayInitialViewportDimensions(
   return null;
 }
 
-export function replayInitialDisplayDimensions(
-  events: AnyReplayEvent[],
-): ReplayViewportDimensions | null {
-  // Keep the initial outer stage and rrweb iframe on one corrected camera.
-  // DO NOT use the raw initial Meta dimensions for only one of those layers.
-  return clampReplayDisplayDimensions(replayInitialViewportDimensions(events));
-}
-
 export function buildReplayViewportTimeline(
   events: AnyReplayEvent[],
 ): ReplayViewportChange[] {
@@ -2384,27 +2391,28 @@ export function normalizeReplayDimensions(
   };
 }
 
-export function clampReplayDisplayDimensions(
+/**
+ * Fall back to the default player size only when the viewport is entirely
+ * unknown (no Meta/ViewportResize event yet). This is not a "recovery"
+ * heuristic for real recorded geometry — it never rewrites valid dims, no
+ * matter how wide, narrow, or unusual the aspect ratio. See the Replayer
+ * construction in ReplayPlayer for why viewport "correction" was removed:
+ * the 2026-07 ultra-wide replay bugs were caused by demo mode's fetch
+ * redaction faking numbers at view time, not by malformed stored geometry.
+ */
+export function resolveReplayDisplayDimensions(
   dims: ReplayViewportDimensions | null,
-): ReplayViewportDimensions | null {
-  if (!dims) return null;
+): ReplayViewportDimensions {
   if (
-    dims.width < MIN_REPLAY_DISPLAY_DIMENSION ||
-    dims.height < MIN_REPLAY_DISPLAY_DIMENSION
+    dims &&
+    Number.isFinite(dims.width) &&
+    Number.isFinite(dims.height) &&
+    dims.width > 0 &&
+    dims.height > 0
   ) {
-    return { width: DEFAULT_PLAYER_WIDTH, height: DEFAULT_PLAYER_HEIGHT };
+    return dims;
   }
-  const aspect = dims.width / dims.height;
-  if (
-    dims.width >= MALFORMED_REPLAY_MIN_WIDTH &&
-    aspect > MALFORMED_REPLAY_MIN_ASPECT_RATIO
-  ) {
-    return {
-      width: Math.round(dims.height * RECOVERED_REPLAY_DISPLAY_ASPECT_RATIO),
-      height: dims.height,
-    };
-  }
-  return dims;
+  return { width: DEFAULT_PLAYER_WIDTH, height: DEFAULT_PLAYER_HEIGHT };
 }
 
 export function filterReplayMarkers(
@@ -2563,6 +2571,20 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(max, Math.max(min, value));
 }
 
+export function shouldPublishReplayClockUpdate(
+  lastUpdateAt: number | null,
+  frameTime: number,
+  currentTime: number,
+  nextTime: number,
+): boolean {
+  if (!Number.isFinite(frameTime) || !Number.isFinite(nextTime)) return false;
+  if (nextTime === currentTime) return false;
+  return (
+    lastUpdateAt == null ||
+    frameTime - lastUpdateAt >= REPLAY_CLOCK_UPDATE_INTERVAL_MS
+  );
+}
+
 function isRecord(value: unknown): value is AnyRecord {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }

package/corpus/templates/analytics/app/pages/sessions/SessionsPage.tsx

@@ -21,7 +21,7 @@ import {
   IconSettings,
 } from "@tabler/icons-react";
 import { useQuery } from "@tanstack/react-query";
-import { useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { Link, useNavigate, useSearchParams } from "react-router";
 import { toast } from "sonner";
 
@@ -167,6 +167,7 @@ type SessionRecordingIdentity = Pick<
 type SessionRecordingDevice = Pick<SessionRecordingSummary, "metadata">;
 
 const RANGE_OPTIONS: ReplayRange[] = ["24h", "7d", "30d", "90d", "all"];
+const SESSION_QUERY_DEBOUNCE_MS = 250;
 
 export default function SessionsPage() {
   const t = useT();
@@ -175,8 +176,38 @@ export default function SessionsPage() {
   const range = readRange(searchParams.get("range"));
   const app = searchParams.get("app") ?? "";
   const query = searchParams.get("q") ?? "";
+  const [queryInput, setQueryInput] = useState(query);
   const from = useMemo(() => rangeToFrom(range), [range]);
 
+  useEffect(() => {
+    setQueryInput(query);
+  }, [query]);
+
+  const updateFilter = useCallback(
+    (key: string, value: string) => {
+      setSearchParams(
+        (current) => {
+          const next = new URLSearchParams(current);
+          const emptyDefault =
+            (key === "range" && value === "30d") || value.trim() === "";
+          if (emptyDefault) next.delete(key);
+          else next.set(key, value);
+          return next;
+        },
+        { replace: true },
+      );
+    },
+    [setSearchParams],
+  );
+
+  useEffect(() => {
+    if (queryInput === query) return;
+    const timeout = window.setTimeout(() => {
+      updateFilter("q", queryInput);
+    }, SESSION_QUERY_DEBOUNCE_MS);
+    return () => window.clearTimeout(timeout);
+  }, [query, queryInput, updateFilter]);
+
   const { data, isLoading, isFetching, refetch, error } = useActionQuery<
     SessionRecordingSummary[]
   >(
@@ -192,15 +223,6 @@ export default function SessionsPage() {
 
   const recordings = data ?? [];
 
-  function updateFilter(key: string, value: string) {
-    const next = new URLSearchParams(searchParams);
-    const emptyDefault =
-      (key === "range" && value === "30d") || value.trim() === "";
-    if (emptyDefault) next.delete(key);
-    else next.set(key, value);
-    setSearchParams(next, { replace: true });
-  }
-
   return (
     <div className="analytics-sessions-page mx-auto flex w-full max-w-7xl flex-col gap-4 px-4 py-5">
       <Card>
@@ -213,8 +235,8 @@ export default function SessionsPage() {
             <div className="analytics-sessions-filter-search relative min-w-0">
               <IconSearch className="pointer-events-none absolute start-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
               <Input
-                value={query}
-                onChange={(event) => updateFilter("q", event.target.value)}
+                value={queryInput}
+                onChange={(event) => setQueryInput(event.target.value)}
                 placeholder={t("sessions.searchPlaceholder")}
                 className="h-9 ps-9"
               />

package/corpus/templates/analytics/changelog/2026-07-12-analytics-chat-retries-before-showing-a-generic-no-data-mess.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Analytics chat retries before showing a generic no-data message

package/corpus/templates/analytics/changelog/2026-07-12-analytics-sessions-search-no-longer-loses-fast-keystrokes-an.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Analytics sessions search no longer loses fast keystrokes, and agent incident lookups no longer stall after background dispatch failures.

package/corpus/templates/analytics/changelog/2026-07-12-chart-selection-respects-chat-state.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Dashboard charts only select for chat when the chat sidebar is already open.

package/corpus/templates/analytics/changelog/2026-07-12-demo-mode-anonymizes-error-reporting-emails.md

@@ -0,0 +1,6 @@
+---
+type: security
+date: 2026-07-12
+---
+
+Demo mode now reliably anonymizes email addresses throughout error reports.

package/corpus/templates/analytics/changelog/2026-07-12-fixed-session-replays-that-appeared-ultra-wide-hid-recorded-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Fixed session replays that appeared ultra-wide, hid recorded menus, or skipped captured cursor movement.

package/corpus/templates/analytics/changelog/2026-07-12-session-replays-load-faster-in-demo-mode-while-visitor-email.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-12
+---
+
+Session replays load faster in demo mode while visitor emails stay anonymized.

package/corpus/templates/analytics/changelog/2026-07-12-session-replays-show-iframe-content.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Session replays now show activity inside extensions and email content.

package/corpus/templates/analytics/netlify.toml

@@ -9,14 +9,11 @@ GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AGENT_PROD_CODE_EXECUTION = "sandboxed"
-AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # Hosted agent chat uses a soft timeout before this function timeout so the
 # hidden auto-continuation path can hand off before Netlify kills the function.
 # If AGENT_RUN_SOFT_TIMEOUT_MS is customized, keep it below this timeout.
-# Agent chat runs are dispatched to the emitted Netlify background function;
-# the normal server timeout still protects non-background HTTP handlers.
 [functions."*"]
 timeout = 75
 

package/corpus/templates/analytics/server/lib/analytics-connector-catalog.ts

@@ -0,0 +1,14 @@
+/**
+ * The deliberately small authenticated MCP surface for Analytics.
+ *
+ * Keep this list read-only and incident-focused. In particular, do not add
+ * replay-event/blob actions or dashboard/data mutation actions here.
+ */
+export const ANALYTICS_CONNECTOR_CATALOG = [
+  "list-session-recordings",
+  "get-session-replay-summary",
+  "get-session-replay-events",
+  "query-agent-native-analytics",
+  "list-error-issues",
+  "get-error-issue",
+] as const;