@agent-native/core 0.98.4 → 0.98.6

package/corpus/templates/analytics/app/hooks/use-dashboard-chat-context.ts

@@ -1,12 +1,14 @@
 import {
+  SIDEBAR_STATE_CHANGE_EVENT,
   deleteClientAppState,
   readClientAppState,
   removeAgentChatContextItem,
   setAgentChatContextItem,
   setClientAppState,
+  type AgentSidebarStateChangeDetail,
   useAgentChatContext,
 } from "@agent-native/core/client";
-import { useCallback, useEffect } from "react";
+import { useCallback, useEffect, useState } from "react";
 
 import { TAB_ID } from "@/lib/tab-id";
 
@@ -120,10 +122,22 @@ function parsePanelSelection(
   }
 }
 
+function isAgentSidebarOpenInDocument(): boolean {
+  if (typeof document === "undefined") return false;
+  return Boolean(
+    document.querySelector(
+      '.agent-sidebar-panel[data-agent-sidebar-state="open"]',
+    ),
+  );
+}
+
 export function useDashboardChatContext(
   args: DashboardChatContextArgs,
 ): DashboardChatContextResult {
   const { id, kind, title, panelCount, canEdit } = args;
+  const [isAgentSidebarOpen, setIsAgentSidebarOpen] = useState(
+    isAgentSidebarOpenInDocument,
+  );
   const { items } = useAgentChatContext();
   const panelContext = items.find(
     (item) => item.key === DASHBOARD_PANEL_CONTEXT_KEY,
@@ -132,7 +146,9 @@ export function useDashboardChatContext(
     ? parsePanelSelection(panelContext.context)
     : null;
   const selectedPanelId =
-    id && panelSelection?.dashboardId === id ? panelSelection.panelId : null;
+    isAgentSidebarOpen && id && panelSelection?.dashboardId === id
+      ? panelSelection.panelId
+      : null;
   const hasSelectedPanel = selectedPanelId !== null;
 
   const selectPanelForChat = useCallback(
@@ -141,6 +157,7 @@ export function useDashboardChatContext(
       options: SelectDashboardPanelOptions = {},
     ) => {
       if (!id) return;
+      if (options.openSidebar !== true && !isAgentSidebarOpen) return;
       const displayDashboardTitle = title?.trim() || id;
       const displayPanelTitle = panel.panelTitle.trim() || panel.panelId;
       const contextLines = [
@@ -166,7 +183,7 @@ export function useDashboardChatContext(
         key: DASHBOARD_PANEL_CONTEXT_KEY,
         title: displayPanelTitle,
         context: contextLines.join("\n"),
-        openSidebar: options.openSidebar ?? true,
+        openSidebar: options.openSidebar === true,
         focus: options.focus ?? false,
       });
       setClientAppState(
@@ -191,9 +208,29 @@ export function useDashboardChatContext(
         },
       ).catch(() => {});
     },
-    [id, kind, title],
+    [id, isAgentSidebarOpen, kind, title],
   );
 
+  useEffect(() => {
+    const handleSidebarStateChange = (event: Event) => {
+      const detail = (event as CustomEvent<AgentSidebarStateChangeDetail>)
+        .detail;
+      if (typeof detail?.open === "boolean") {
+        setIsAgentSidebarOpen(detail.open);
+      }
+    };
+
+    window.addEventListener(
+      SIDEBAR_STATE_CHANGE_EVENT,
+      handleSidebarStateChange,
+    );
+    return () =>
+      window.removeEventListener(
+        SIDEBAR_STATE_CHANGE_EVENT,
+        handleSidebarStateChange,
+      );
+  }, []);
+
   useEffect(() => {
     if (!id) return;
     const displayTitle = title?.trim() || id;

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

@@ -166,16 +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;
-// Evidence-backed exception for the one pre-fix viewport shape observed in a
-// stored recording. Do not broaden this to an aspect-ratio range: valid
-// 3440x900 ultrawide browser viewports occupy the same range.
-const LEGACY_MALFORMED_REPLAY_WIDTH = 3189;
-const LEGACY_MALFORMED_REPLAY_HEIGHT = 885;
-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;
@@ -509,7 +499,7 @@ function ReplayPlayer({
   } | null>(null);
   const [fitScale, setFitScale] = useState(1);
   const initialDims = useMemo(
-    () => replayInitialDisplayDimensions(events),
+    () => replayInitialViewportDimensions(events),
     [events],
   );
   const viewportTimeline = useMemo(
@@ -531,17 +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 3,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, plus the exact known 3,189x885 legacy
-  // shape, 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);
@@ -671,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);
@@ -748,24 +733,18 @@ 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);
-      // The legacy malformed-width recordings need one paired exception to
-      // raw-event pass-through: pointer coordinates were captured in the same
-      // impossible viewport coordinate space. Correcting only the iframe makes
-      // rrweb cast clicks thousands of pixels off-stage. Project pointer data
-      // with each malformed Meta/resize while retaining every other raw field.
-      const playerEvents = projectReplayPointerCoordinates(replayEvents);
-      // Keep this loosely typed because the legacy viewport recovery below
-      // intentionally calls rrweb's runtime handleResize hook, which its
-      // TypeScript declaration marks private.
-      localReplayer = new Replayer(playerEvents as any[], {
+      // 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,
@@ -778,17 +757,6 @@ function ReplayPlayer({
         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 as any).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.
@@ -821,30 +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.
-          if (
-            correctedDims.width !== rawDims.width ||
-            correctedDims.height !== rawDims.height
-          ) {
-            // rrweb applies the raw Meta/ViewportResize to its iframe before
-            // emitting this callback. Re-apply the correction every time the
-            // raw event is malformed, even when React already stores the same
-            // corrected dimensions. Returning early here recreates the exact
-            // bug where the outer stage is normal but the iframe is ultra-wide.
-            (localReplayer as any).handleResize?.(correctedDims);
-          }
+          // 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;
           }
-          setStreamedDims(correctedDims);
+          setStreamedDims(rawDims);
         }
       });
       updateTime(startAt);
@@ -1994,102 +1949,6 @@ export function normalizeReplayEvents(events: unknown[]): AnyReplayEvent[] {
     .sort((a, b) => Number(a.timestamp ?? 0) - Number(b.timestamp ?? 0));
 }
 
-/**
- * Pair pointer coordinates with the narrowly gated legacy viewport recovery.
- *
- * IMPORTANT: do not apply this to normal recordings and do not rewrite the
- * Meta/resize events themselves. rrweb must still rebuild the captured DOM
- * from raw events; only pointer coordinates need projection into the corrected
- * iframe camera. Returning original references for untouched events keeps this
- * compatible with stock rrweb and avoids cloning large snapshots.
- */
-export function projectReplayPointerCoordinates(
-  events: AnyReplayEvent[],
-): AnyReplayEvent[] {
-  let rawDims: ReplayViewportDimensions | null = null;
-  let displayDims: ReplayViewportDimensions | null = null;
-
-  return events.map((event) => {
-    const nextDims = dimensionsFromReplayEvent(event);
-    if (nextDims) {
-      rawDims = nextDims;
-      displayDims = clampReplayDisplayDimensions(nextDims);
-      return event;
-    }
-    if (
-      !rawDims ||
-      !displayDims ||
-      (rawDims.width === displayDims.width &&
-        rawDims.height === displayDims.height) ||
-      event.type !== RRWEB_EVENT_TYPE.IncrementalSnapshot
-    ) {
-      return event;
-    }
-
-    const source = event.data?.source;
-    if (source === INCREMENTAL_SOURCE.MouseInteraction) {
-      const data = projectReplayPointerData(event.data, rawDims, displayDims);
-      return data === event.data ? event : { ...event, data };
-    }
-    if (
-      source !== INCREMENTAL_SOURCE.MouseMove &&
-      source !== INCREMENTAL_SOURCE.TouchMove &&
-      source !== INCREMENTAL_SOURCE.Drag
-    ) {
-      return event;
-    }
-    const positions = Array.isArray(event.data?.positions)
-      ? event.data.positions
-      : [];
-    let changed = false;
-    const projectedPositions = positions.map((position: unknown) => {
-      if (!isRecord(position)) return position;
-      const projected = projectReplayPointerData(
-        position,
-        rawDims!,
-        displayDims!,
-      );
-      if (projected !== position) changed = true;
-      return projected;
-    });
-    return changed
-      ? { ...event, data: { ...event.data, positions: projectedPositions } }
-      : event;
-  });
-}
-
-function projectReplayPointerData(
-  data: AnyReplayEvent,
-  rawDims: ReplayViewportDimensions,
-  displayDims: ReplayViewportDimensions,
-): AnyReplayEvent {
-  const projectedX = projectReplayCoordinate(
-    data.x,
-    displayDims.width / rawDims.width,
-    displayDims.width,
-  );
-  const projectedY = projectReplayCoordinate(
-    data.y,
-    displayDims.height / rawDims.height,
-    displayDims.height,
-  );
-  if (projectedX === data.x && projectedY === data.y) return data;
-  return {
-    ...data,
-    ...(projectedX !== undefined ? { x: projectedX } : {}),
-    ...(projectedY !== undefined ? { y: projectedY } : {}),
-  };
-}
-
-function projectReplayCoordinate(
-  value: unknown,
-  scale: number,
-  maximum: number,
-): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
-  return clamp(value * scale, 0, Math.max(0, maximum - 1));
-}
-
 export function buildReplayMarkers(events: AnyReplayEvent[]): ReplayMarker[] {
   const startedAt = replayStartedAt(events);
   const markers: ReplayMarker[] = [];
@@ -2447,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[] {
@@ -2540,30 +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 };
-  }
-  const aspect = dims.width / dims.height;
-  const hasMalformedWideGeometry =
-    dims.width >= MALFORMED_REPLAY_MIN_WIDTH &&
-    aspect > MALFORMED_REPLAY_MIN_ASPECT_RATIO;
-  const hasLegacyMalformedWideGeometry =
-    dims.width === LEGACY_MALFORMED_REPLAY_WIDTH &&
-    dims.height === LEGACY_MALFORMED_REPLAY_HEIGHT;
-  if (hasMalformedWideGeometry || hasLegacyMalformedWideGeometry) {
-    return {
-      width: Math.round(dims.height * RECOVERED_REPLAY_DISPLAY_ASPECT_RATIO),
-      height: dims.height,
-    };
+    return dims;
   }
-  return dims;
+  return { width: DEFAULT_PLAYER_WIDTH, height: DEFAULT_PLAYER_HEIGHT };
 }
 
 export function filterReplayMarkers(

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, useRef, useState } from "react";
 import { Link, useNavigate, useSearchParams } from "react-router";
 import { toast } from "sonner";
 
@@ -167,6 +167,41 @@ type SessionRecordingIdentity = Pick<
 type SessionRecordingDevice = Pick<SessionRecordingSummary, "metadata">;
 
 const RANGE_OPTIONS: ReplayRange[] = ["24h", "7d", "30d", "90d", "all"];
+const SESSION_QUERY_DEBOUNCE_MS = 250;
+
+/**
+ * Local input state for a URL-backed filter, debounced into the URL.
+ *
+ * `urlValue` only resyncs local state when it changes for a reason other
+ * than this hook's own debounced write (back/forward navigation, an agent
+ * driven URL change, etc). React Router commits `setSearchParams` inside a
+ * transition, so without this guard the echo of our own write can land
+ * after a newer keystroke and clobber it.
+ */
+export function useDebouncedUrlFilter(
+  urlValue: string,
+  onCommit: (value: string) => void,
+): [string, (value: string) => void] {
+  const [input, setInput] = useState(urlValue);
+  const lastPushedRef = useRef(urlValue);
+
+  useEffect(() => {
+    if (urlValue === lastPushedRef.current) return;
+    lastPushedRef.current = urlValue;
+    setInput(urlValue);
+  }, [urlValue]);
+
+  useEffect(() => {
+    if (input === urlValue) return;
+    const timeout = window.setTimeout(() => {
+      lastPushedRef.current = input;
+      onCommit(input);
+    }, SESSION_QUERY_DEBOUNCE_MS);
+    return () => window.clearTimeout(timeout);
+  }, [input, urlValue, onCommit]);
+
+  return [input, setInput];
+}
 
 export default function SessionsPage() {
   const t = useT();
@@ -177,6 +212,35 @@ export default function SessionsPage() {
   const query = searchParams.get("q") ?? "";
   const from = useMemo(() => rangeToFrom(range), [range]);
 
+  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],
+  );
+
+  const commitQuery = useCallback(
+    (value: string) => updateFilter("q", value),
+    [updateFilter],
+  );
+  const [queryInput, setQueryInput] = useDebouncedUrlFilter(query, commitQuery);
+
+  const commitApp = useCallback(
+    (value: string) => updateFilter("app", value),
+    [updateFilter],
+  );
+  const [appInput, setAppInput] = useDebouncedUrlFilter(app, commitApp);
+
   const { data, isLoading, isFetching, refetch, error } = useActionQuery<
     SessionRecordingSummary[]
   >(
@@ -192,15 +256,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 +268,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"
               />
@@ -269,10 +324,8 @@ export default function SessionsPage() {
                       {t("sessions.userFilters")}
                     </div>
                     <Input
-                      value={app}
-                      onChange={(event) =>
-                        updateFilter("app", event.target.value)
-                      }
+                      value={appInput}
+                      onChange={(event) => setAppInput(event.target.value)}
                       placeholder={t("sessions.appPlaceholder")}
                       className="h-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-connected-external-agents-can-now-look-up-sessions-error-iss.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-12
+---
+
+Connected external agents can now look up sessions, error issues, and sanitized replay timelines directly, with the app agent remaining the default path.

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-session-identities-stay-visible-when-demo-mode-is-off.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-12
+---
+
+Session identities stay visible when Demo mode is off

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
+ * raw 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-timeline",
+  "query-agent-native-analytics",
+  "list-error-issues",
+  "get-error-issue",
+] as const;