@agent-native/core 0.98.5 → 0.98.7

package/corpus/templates/analytics/server/handlers/session-replay.ts

@@ -12,8 +12,8 @@ import {
 
 import { runApiHandlerWithContext } from "../lib/credentials";
 import {
+  resolveSessionReplayAgentAccess,
   SESSION_REPLAY_AGENT_ACCESS_PARAM,
-  verifySessionReplayAgentAccess,
 } from "../lib/session-replay-agent-context.js";
 import {
   getSessionReplayManifest,
@@ -236,12 +236,13 @@ function replayChunkSeqsFromQuery(query: Record<string, unknown>): number[] {
 function verifyAgentReplayAccessToken(
   event: any,
   recordingId: string,
-): string | null {
+): { token: string; viewerEmail: string } | null | false {
   const token = readAgentReplayAccessToken(event);
   if (!token) return null;
-  if (verifySessionReplayAgentAccess(recordingId, token)) return token;
+  const access = resolveSessionReplayAgentAccess(recordingId, token);
+  if (access) return { token, viewerEmail: access.viewerEmail };
   setResponseStatus(event, 401);
-  return "";
+  return false;
 }
 
 function listFiltersFromQuery(
@@ -371,13 +372,16 @@ export const handleSessionReplayManifest = defineEventHandler(async (event) => {
   }
 
   const agentAccessToken = verifyAgentReplayAccessToken(event, recordingId);
-  if (agentAccessToken === "") {
+  if (agentAccessToken === false) {
     return { error: "Invalid or expired agent access" };
   }
   if (agentAccessToken) {
     try {
       applyAgentReplayReadHeaders(event);
-      const manifest = await getSessionReplayTokenizedManifest(recordingId);
+      const manifest = await getSessionReplayTokenizedManifest(
+        recordingId,
+        agentAccessToken.viewerEmail,
+      );
       return {
         ...manifest,
         chunks: manifest.chunks.map((chunk) => ({
@@ -385,7 +389,7 @@ export const handleSessionReplayManifest = defineEventHandler(async (event) => {
           bytesPath: appendQueryParam(
             chunk.bytesPath,
             SESSION_REPLAY_AGENT_ACCESS_PARAM,
-            agentAccessToken,
+            agentAccessToken.token,
           ),
         })),
       };
@@ -419,7 +423,7 @@ export const handleSessionReplayChunkBytes = defineEventHandler(
     }
 
     const agentAccessToken = verifyAgentReplayAccessToken(event, recordingId);
-    if (agentAccessToken === "") {
+    if (agentAccessToken === false) {
       return { error: "Invalid or expired agent access" };
     }
     if (agentAccessToken) {
@@ -427,6 +431,7 @@ export const handleSessionReplayChunkBytes = defineEventHandler(
         const result = await readSessionReplayTokenizedChunkBytes(
           recordingId,
           seq,
+          agentAccessToken.viewerEmail,
         );
         applyAgentReplayReadHeaders(event);
         setResponseHeader(event, "Content-Type", "application/json");
@@ -472,7 +477,7 @@ export const handleSessionReplayChunkBatch = defineEventHandler(
     const seqs = replayChunkSeqsFromQuery(getQuery(event));
 
     const agentAccessToken = verifyAgentReplayAccessToken(event, recordingId);
-    if (agentAccessToken === "") {
+    if (agentAccessToken === false) {
       return { error: "Invalid or expired agent access" };
     }
     if (agentAccessToken) {
@@ -480,6 +485,7 @@ export const handleSessionReplayChunkBatch = defineEventHandler(
         const result = await readSessionReplayTokenizedChunkBatch(
           recordingId,
           seqs,
+          agentAccessToken.viewerEmail,
         );
         applyAgentReplayReadHeaders(event);
         setResponseHeader(event, "Content-Type", "application/json");

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

@@ -2,12 +2,12 @@
  * 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.
+ * 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-events",
+  "get-session-replay-timeline",
   "query-agent-native-analytics",
   "list-error-issues",
   "get-error-issue",

package/corpus/templates/analytics/server/lib/error-capture.ts

@@ -18,7 +18,7 @@ import { fileURLToPath } from "node:url";
  * reads go through `accessFilter` so an org-scoped key surfaces its issues to
  * the whole org exactly like session recordings.
  */
-import { readAppState } from "@agent-native/core/application-state";
+import { appStateGet } from "@agent-native/core/application-state";
 import { notifyWithDelivery } from "@agent-native/core/notifications";
 import { recordChange } from "@agent-native/core/server";
 import { accessFilter } from "@agent-native/core/sharing";
@@ -26,6 +26,7 @@ import {
   and,
   desc,
   eq,
+  exists,
   inArray,
   isNull,
   notInArray,
@@ -1073,6 +1074,8 @@ export interface ListErrorIssuesFilters {
   status?: IssueStatus | "all";
   query?: string;
   app?: string;
+  sessionRecordingId?: string;
+  userId?: string;
   sort?: "lastSeen" | "eventCount" | "firstSeen";
   limit?: number;
 }
@@ -1106,10 +1109,14 @@ export function anonymizeErrorReportingEmails<T>(value: T): T {
   return value;
 }
 
-async function isErrorDemoModeEnabled(): Promise<boolean> {
+async function isErrorDemoModeEnabled(
+  userEmail?: string | null,
+): Promise<boolean> {
   if (process.env.DEMO_MODE === "true") return true;
+  if (!userEmail) return false;
   try {
-    const state = await readAppState("demo-mode");
+    // Keep demo state tied to the caller whose issues are being read.
+    const state = await appStateGet(userEmail, "demo-mode");
     return state?.enabled === true;
   } catch {
     return false;
@@ -1195,7 +1202,7 @@ export async function listErrorIssues(
   scope: ErrorReadScope,
   filters: ListErrorIssuesFilters = {},
 ): Promise<ErrorIssueSummary[]> {
-  const demoModeEnabled = isErrorDemoModeEnabled();
+  const demoModeEnabled = isErrorDemoModeEnabled(scope.userEmail);
   const db = getDb() as any;
   const limit = Math.min(
     MAX_ISSUE_LIMIT,
@@ -1206,6 +1213,41 @@ export async function listErrorIssues(
     conditions.push(eq(schema.errorIssues.status, filters.status));
   }
   if (filters.app) conditions.push(eq(schema.errorIssues.app, filters.app));
+  const sessionRecordingId = filters.sessionRecordingId?.trim();
+  const userId = filters.userId?.trim();
+  if (sessionRecordingId || userId) {
+    const occurrenceConditions: any[] = [
+      eq(schema.errorEvents.issueId, schema.errorIssues.id),
+      // Keep the child occurrence in the same tenant as its parent issue even
+      // when the issue is visible through an org share.
+      eq(schema.errorEvents.ownerEmail, schema.errorIssues.ownerEmail),
+      or(
+        eq(schema.errorEvents.orgId, schema.errorIssues.orgId),
+        and(isNull(schema.errorEvents.orgId), isNull(schema.errorIssues.orgId)),
+      ),
+    ];
+    if (sessionRecordingId) {
+      occurrenceConditions.push(
+        eq(schema.errorEvents.sessionRecordingId, sessionRecordingId),
+      );
+    }
+    if (userId) {
+      occurrenceConditions.push(
+        or(
+          eq(schema.errorEvents.userId, userId),
+          eq(schema.errorEvents.userKey, userId),
+        ),
+      );
+    }
+    conditions.push(
+      exists(
+        db
+          .select({ id: schema.errorEvents.id })
+          .from(schema.errorEvents)
+          .where(and(...occurrenceConditions)),
+      ),
+    );
+  }
   const query = filters.query?.trim();
   if (query) {
     conditions.push(
@@ -1343,7 +1385,7 @@ export async function getErrorIssue(
   issueId: string,
   options: { eventsLimit?: number } = {},
 ): Promise<ErrorIssueDetail> {
-  const demoModeEnabled = isErrorDemoModeEnabled();
+  const demoModeEnabled = isErrorDemoModeEnabled(scope.userEmail);
   const db = getDb() as any;
   const [issueRow] = await db
     .select()

package/corpus/templates/analytics/server/lib/session-replay-agent-context.ts

@@ -22,6 +22,7 @@ import {
 } from "../../shared/session-replay-diagnostics.js";
 import {
   compactSessionRecordingSummary,
+  getSessionReplayEvents,
   getSessionReplaySummary,
   getSessionReplayTokenizedEvents,
   getSessionReplayTokenizedSummary,
@@ -82,20 +83,16 @@ function replayStartedAt(events: AgentReplayEvent[]): number {
 
 function pathLabel(href: string): string {
   try {
-    const parsed = new URL(href);
-    return parsed.pathname || parsed.hostname;
+    const parsed = new URL(href, "https://placeholder.agent-native.local");
+    return boundedDiagnosticText(
+      parsed.pathname || parsed.hostname,
+      MAX_DIAGNOSTIC_URL_CHARS,
+    );
   } catch {
-    return href;
+    return boundedDiagnosticText(href, MAX_DIAGNOSTIC_URL_CHARS);
   }
 }
 
-function markerDetail(event: AgentReplayEvent): string | null {
-  const payload = event.data?.payload;
-  if (typeof payload?.message === "string") return payload.message;
-  if (typeof event.data?.href === "string") return event.data.href;
-  return null;
-}
-
 const TIMELINE_MARKER_CAP = 200;
 const TIMELINE_ERROR_MARKER_RESERVE = 100;
 const MAX_DIAGNOSTIC_MESSAGE_CHARS = 1_000;
@@ -528,10 +525,9 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
         if (isFailedSessionReplayNetworkStatus(status)) {
           const method =
             boundedDiagnosticText(tagged.payload.method, 16) || "GET";
-          const url = boundedDiagnosticText(
-            tagged.payload.url,
-            MAX_DIAGNOSTIC_URL_CHARS,
-          );
+          // External-agent timelines intentionally expose only a path label.
+          // Query strings commonly contain emails, tokens, and other secrets.
+          const url = pathLabel(String(tagged.payload.url ?? ""));
           markers.push({
             timestamp,
             offsetMs: Math.max(0, timestamp - startedAt),
@@ -553,7 +549,7 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
         offsetMs: Math.max(0, timestamp - startedAt),
         kind: "navigation",
         label: pathLabel(event.data.href),
-        detail: event.data.href,
+        detail: pathLabel(event.data.href),
       });
     } else if (
       event.type === RRWEB_EVENT_TYPE.IncrementalSnapshot &&
@@ -606,8 +602,14 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
         timestamp,
         offsetMs: Math.max(0, timestamp - startedAt),
         kind: "custom",
-        label: String(event.data?.tag ?? "Custom event"),
-        detail: markerDetail(event),
+        label: boundedDiagnosticText(
+          String(event.data?.tag ?? "Custom event"),
+          MAX_DIAGNOSTIC_MESSAGE_CHARS,
+        ),
+        // Custom-event payloads are application-defined and can contain input
+        // values or secrets. The tag and timestamp are sufficient metadata for
+        // this sanitized external-agent timeline.
+        detail: null,
       });
     }
   }
@@ -615,14 +617,56 @@ function buildReplayTimeline(events: AgentReplayEvent[]) {
   return capReplayTimelineMarkers(markers);
 }
 
+export async function getSessionReplayTimeline(
+  recordingId: string,
+  scope: ReplayScope,
+  options: { eventLimit?: number } = {},
+) {
+  const eventLimit = Math.min(
+    10_000,
+    Math.max(1, Math.floor(options.eventLimit ?? 10_000)),
+  );
+  const eventsResponse = await getSessionReplayEvents(recordingId, scope, {
+    limit: eventLimit,
+  });
+  const events = eventsResponse.chunks.flatMap((chunk) =>
+    chunk.events.filter(
+      (event): event is AgentReplayEvent =>
+        Boolean(event) && typeof event === "object",
+    ),
+  );
+  const markers = buildReplayTimeline(events);
+
+  return {
+    recording: compactSessionRecordingSummary(eventsResponse.recording),
+    markerCount: markers.length,
+    markers,
+    eventCount: eventsResponse.eventCount,
+    truncated: eventsResponse.truncated,
+    unavailableChunks: eventsResponse.unavailableChunks,
+  };
+}
+
 export function verifySessionReplayAgentAccess(
   recordingId: string,
   token: string,
 ): boolean {
-  return verifyScopedAgentAccessToken(token, {
+  return resolveSessionReplayAgentAccess(recordingId, token) !== null;
+}
+
+export function resolveSessionReplayAgentAccess(
+  recordingId: string,
+  token: string,
+): { viewerEmail: string } | null {
+  const result = verifyScopedAgentAccessToken(token, {
     resourceKind: SESSION_REPLAY_AGENT_ACCESS_TOKEN_PREFIX,
     resourceId: recordingId,
-  }).ok;
+  });
+  // Replay grants are always minted by an authenticated viewer. Fail closed
+  // for grants without that signed identity: demo-mode policy is viewer-scoped,
+  // so guessing from the ambient request could expose identities to agents.
+  if (!result.ok || !result.viewerEmail) return null;
+  return { viewerEmail: result.viewerEmail };
 }
 
 export async function createSessionReplayAgentLink({
@@ -675,14 +719,18 @@ export async function buildSessionReplayAgentContext({
   origin?: string;
   includeTimeline?: boolean;
 }) {
-  if (!verifySessionReplayAgentAccess(recordingId, token)) {
+  const access = resolveSessionReplayAgentAccess(recordingId, token);
+  if (!access) {
     const error = Object.assign(new Error("Invalid or expired agent access"), {
       statusCode: 401,
     });
     throw error;
   }
 
-  const recording = await getSessionReplayTokenizedSummary(recordingId);
+  const recording = await getSessionReplayTokenizedSummary(
+    recordingId,
+    access.viewerEmail,
+  );
   const resolvedOrigin = appOrigin(origin);
   const basePath = appBasePath();
   const contextUrl = buildAgentAccessApiUrl({
@@ -715,7 +763,9 @@ export async function buildSessionReplayAgentContext({
   });
 
   const eventsResponse = includeTimeline
-    ? await getSessionReplayTokenizedEvents(recording.id, { limit: 10000 })
+    ? await getSessionReplayTokenizedEvents(recording.id, access.viewerEmail, {
+        limit: 10000,
+      })
     : null;
   const events =
     eventsResponse?.chunks.flatMap((chunk) =>

package/corpus/templates/analytics/server/lib/session-replay.ts

@@ -2,14 +2,18 @@ import { Buffer } from "node:buffer";
 import { createHash, randomUUID } from "node:crypto";
 import { gzipSync, gunzipSync } from "node:zlib";
 
-import { readAppState } from "@agent-native/core/application-state";
+import { appStateGet } from "@agent-native/core/application-state";
 import {
   deletePrivateBlob,
   putPrivateBlob,
   readPrivateBlob,
   type PrivateBlobHandle,
 } from "@agent-native/core/private-blob";
-import { recordChange, runWithRequestContext } from "@agent-native/core/server";
+import {
+  getRequestUserEmail,
+  recordChange,
+  runWithRequestContext,
+} from "@agent-native/core/server";
 import {
   accessFilter,
   resolveAccess,
@@ -301,10 +305,15 @@ function isBuilderEmail(value: unknown): boolean {
   return normalizedEmail(value)?.endsWith("@builder.io") === true;
 }
 
-async function isSessionDemoModeEnabled(): Promise<boolean> {
+async function isSessionDemoModeEnabled(
+  userEmail?: string | null,
+): Promise<boolean> {
   if (process.env.DEMO_MODE === "true") return true;
+  if (!userEmail) return false;
   try {
-    const state = await readAppState("demo-mode");
+    // These reads also run from custom routes and actions, so use the
+    // authenticated scope explicitly instead of ambient request state.
+    const state = await appStateGet(userEmail, "demo-mode");
     return state?.enabled === true;
   } catch {
     return false;
@@ -1677,7 +1686,7 @@ export async function listSessionRecordings(
   filters: SessionReplayListFilters = {},
 ): Promise<SessionRecordingSummary[]> {
   const db = getDb() as any;
-  const demoMode = await isSessionDemoModeEnabled();
+  const demoMode = await isSessionDemoModeEnabled(scope.userEmail);
   const limit = Math.min(
     MAX_SESSION_RECORDINGS_LIMIT,
     Math.max(1, filters.limit ?? DEFAULT_SESSION_RECORDINGS_LIMIT),
@@ -1759,7 +1768,7 @@ export async function getSessionReplaySummary(
   recordingId: string,
   scope: SessionReplayScope,
 ): Promise<SessionRecordingSummary> {
-  const demoMode = await isSessionDemoModeEnabled();
+  const demoMode = await isSessionDemoModeEnabled(scope.userEmail);
   const access = await resolveAccess("session-recording", recordingId, {
     userEmail: scope.userEmail,
     orgId: scope.orgId ?? undefined,
@@ -1777,8 +1786,13 @@ export async function getSessionReplaySummary(
 
 export async function getSessionReplayTokenizedSummary(
   recordingId: string,
+  viewerEmail: string,
 ): Promise<SessionRecordingSummary> {
-  const demoMode = await isSessionDemoModeEnabled();
+  // Tokenized reads often run without an authenticated request session. Use
+  // the viewer identity embedded in the signed, recording-scoped grant so a
+  // link minted while demo mode is enabled cannot reveal real identities when
+  // it is opened in a signed-out browser or by an external agent.
+  const demoMode = await isSessionDemoModeEnabled(viewerEmail);
   const db = getDb() as any;
   // guard:allow-unscoped -- called only after verifySessionReplayAgentAccess(recordingId, token) verifies a signed, recording-scoped agent_access token.
   const [row] = await db
@@ -1838,6 +1852,7 @@ export async function getSessionReplayManifest(
 
 export async function getSessionReplayTokenizedManifest(
   recordingId: string,
+  viewerEmail: string,
 ): Promise<{
   recording: AgentSessionRecordingSummary;
   chunks: Array<{
@@ -1850,7 +1865,10 @@ export async function getSessionReplayTokenizedManifest(
     bytesPath: string;
   }>;
 }> {
-  const recording = await getSessionReplayTokenizedSummary(recordingId);
+  const recording = await getSessionReplayTokenizedSummary(
+    recordingId,
+    viewerEmail,
+  );
   const manifest = await getSessionReplayManifestForRecording(recording);
   return {
     ...manifest,
@@ -1914,6 +1932,7 @@ export async function readSessionReplayChunkBytes(
 export async function readSessionReplayTokenizedChunkBytes(
   recordingId: string,
   seq: number,
+  viewerEmail: string,
 ): Promise<{
   recording: AgentSessionRecordingSummary;
   seq: number;
@@ -1921,7 +1940,10 @@ export async function readSessionReplayTokenizedChunkBytes(
   /** Decompressed replay-chunk JSON text (a serialized rrweb events array). */
   json: string;
 }> {
-  const recording = await getSessionReplayTokenizedSummary(recordingId);
+  const recording = await getSessionReplayTokenizedSummary(
+    recordingId,
+    viewerEmail,
+  );
   const chunk = await readSessionReplayChunkBytesForRecording(recording, seq);
   return {
     ...chunk,
@@ -2166,8 +2188,12 @@ export async function readSessionReplayChunkBatch(
 export async function readSessionReplayTokenizedChunkBatch(
   recordingId: string,
   seqs: number[],
+  viewerEmail: string,
 ): Promise<SessionReplayChunkBatchResult> {
-  const recording = await getSessionReplayTokenizedSummary(recordingId);
+  const recording = await getSessionReplayTokenizedSummary(
+    recordingId,
+    viewerEmail,
+  );
   return readSessionReplayChunkBatchForRecording(recording, seqs);
 }
 
@@ -2195,6 +2221,7 @@ export async function getSessionReplayEvents(
 
 export async function getSessionReplayTokenizedEvents(
   recordingId: string,
+  viewerEmail: string,
   options: SessionReplayEventReadOptions = {},
 ): Promise<{
   recording: AgentSessionRecordingSummary;
@@ -2210,7 +2237,10 @@ export async function getSessionReplayTokenizedEvents(
   truncated: boolean;
   unavailableChunks: number;
 }> {
-  const recording = await getSessionReplayTokenizedSummary(recordingId);
+  const recording = await getSessionReplayTokenizedSummary(
+    recordingId,
+    viewerEmail,
+  );
   const result = await getSessionReplayEventsForRecording(recording, options);
   return {
     ...result,

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -258,6 +258,13 @@ export default createAgentChatPlugin({
   // AGENT_PROD_CODE_EXECUTION=trusted to also enable bash/read/edit/write.
   codeExecution: { production: "sandboxed" },
   connectorCatalog: [...ANALYTICS_CONNECTOR_CATALOG],
+  externalAgents: {
+    // Keep the direct MCP surface deliberately curated. External agents
+    // should use ask_app for multi-step investigation; these six actions are
+    // bounded fallback reads for callers that already know what they need.
+    authenticatedReads: "off",
+    writes: "ask_app_only",
+  },
   resolveOrgId: async (event) => {
     const ctx = await getOrgContext(event);
     return ctx.orgId;

package/corpus/templates/analytics/server/plugins/db.ts

@@ -1249,6 +1249,21 @@ const runAnalyticsMigrations = runMigrations(
         sqlite: `ALTER TABLE monitor_incidents ADD COLUMN IF NOT EXISTS notification_delivered INTEGER NOT NULL DEFAULT 0`,
       },
     },
+    {
+      version: 118,
+      name: "error-events-session-recording-filter-idx",
+      sql: `CREATE INDEX IF NOT EXISTS error_events_session_recording_filter_idx ON error_events (session_recording_id, owner_email, org_id, issue_id)`,
+    },
+    {
+      version: 119,
+      name: "error-events-user-id-filter-idx",
+      sql: `CREATE INDEX IF NOT EXISTS error_events_user_id_filter_idx ON error_events (user_id, owner_email, org_id, issue_id)`,
+    },
+    {
+      version: 120,
+      name: "error-events-user-key-filter-idx",
+      sql: `CREATE INDEX IF NOT EXISTS error_events_user_key_filter_idx ON error_events (user_key, owner_email, org_id, issue_id)`,
+    },
   ],
   { table: "analytics_migrations" },
 );

package/corpus/templates/analytics/server/routes/api/session-replay/agent-diagnostics.json.get.ts

@@ -8,8 +8,8 @@ import {
 import { type SessionReplayConsoleLevel } from "../../../../shared/session-replay-diagnostics.js";
 import {
   buildSessionReplayDiagnostics,
+  resolveSessionReplayAgentAccess,
   SESSION_REPLAY_AGENT_ACCESS_PARAM,
-  verifySessionReplayAgentAccess,
 } from "../../../lib/session-replay-agent-context.js";
 import { getSessionReplayTokenizedEvents } from "../../../lib/session-replay.js";
 
@@ -48,7 +48,8 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 400);
     return { error: "id and agent access token are required" };
   }
-  if (!verifySessionReplayAgentAccess(id, token)) {
+  const access = resolveSessionReplayAgentAccess(id, token);
+  if (!access) {
     setResponseStatus(event, 401);
     return { error: "Invalid or expired agent access" };
   }
@@ -108,9 +109,11 @@ export default defineEventHandler(async (event) => {
           : (rawOffset ? offset : 0) + limit,
       ),
     );
-    const eventsResponse = await getSessionReplayTokenizedEvents(id, {
-      limit: replayEventReadLimit,
-    });
+    const eventsResponse = await getSessionReplayTokenizedEvents(
+      id,
+      access.viewerEmail,
+      { limit: replayEventReadLimit },
+    );
     const events = eventsResponse.chunks.flatMap((chunk) =>
       chunk.events.filter(
         (item): item is Record<string, any> =>

package/corpus/templates/analytics/server/routes/api/session-replay/agent-events.json.get.ts

@@ -6,8 +6,8 @@ import {
 } from "h3";
 
 import {
+  resolveSessionReplayAgentAccess,
   SESSION_REPLAY_AGENT_ACCESS_PARAM,
-  verifySessionReplayAgentAccess,
 } from "../../../lib/session-replay-agent-context.js";
 import {
   getSessionReplayTokenizedEvents,
@@ -43,7 +43,8 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 400);
     return { error: "id and agent access token are required" };
   }
-  if (!verifySessionReplayAgentAccess(id, token)) {
+  const access = resolveSessionReplayAgentAccess(id, token);
+  if (!access) {
     setResponseStatus(event, 401);
     return { error: "Invalid or expired agent access" };
   }
@@ -55,7 +56,11 @@ export default defineEventHandler(async (event) => {
   };
 
   try {
-    return await getSessionReplayTokenizedEvents(id, options);
+    return await getSessionReplayTokenizedEvents(
+      id,
+      access.viewerEmail,
+      options,
+    );
   } catch (error: any) {
     setResponseStatus(event, error?.statusCode ?? 400);
     return { error: error?.message || String(error) };

package/corpus/templates/calendar/app/components/calendar/DeleteEventDialog.tsx

@@ -37,6 +37,7 @@ export function DeleteEventDialog({
 }: DeleteEventDialogProps) {
   const t = useT();
   const confirmButtonRef = useRef<HTMLButtonElement>(null);
+  const dontNotifyButtonRef = useRef<HTMLButtonElement>(null);
   const [scope, setScope] = useState<DeleteEventScope>("single");
   const [message, setMessage] = useState("");
 
@@ -114,7 +115,12 @@ export function DeleteEventDialog({
         onKeyDown={handleKeyDown}
         onOpenAutoFocus={(event) => {
           event.preventDefault();
-          confirmButtonRef.current?.focus();
+          // For events with guests, Enter should default to the reversible,
+          // no-email path instead of immediately sending a cancellation.
+          (canNotifyGuests
+            ? dontNotifyButtonRef.current
+            : confirmButtonRef.current
+          )?.focus();
         }}
       >
         <AlertDialogHeader>
@@ -177,7 +183,11 @@ export function DeleteEventDialog({
             {t("deleteEvent.cancel")}
           </AlertDialogCancel>
           {canNotifyGuests && (
-            <Button variant="outline" onClick={() => handleConfirm("none")}>
+            <Button
+              ref={dontNotifyButtonRef}
+              variant="outline"
+              onClick={() => handleConfirm("none")}
+            >
               {t("deleteEvent.dontNotify")}
             </Button>
           )}