@agent-native/core 0.175.4 → 0.176.0-nightly-20260826210104

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8623
+- template files: 8631

package/corpus/templates/clips/.agents/skills/ai-video-tools/SKILL.md

@@ -141,18 +141,19 @@ removing overlapping duplicate speech and low-speech Whisper hallucinations. Kee
 system audio enabled when the meeting audio comes from another app.
 
 Native transcript first is a hard rule, not a preference: cloud transcription is
-fallback-only for Clips recordings. Cleanup and transcript-backed title/summary
-generation run in the durable post-finalize path, so never hide a usable native
-transcript behind failed metadata work, and keep heuristic titles replaceable
-until the agent refinement lands.
+fallback-only for Clips recordings. Recording transcripts keep the native text as
+captured; `request-transcript` does not run automatic cleanup. Never hide a
+usable native transcript behind failed metadata work, and keep heuristic titles
+replaceable until the agent refinement lands. The standalone `cleanup-transcript`
+action remains available for explicit dictation, meeting, and agent workflows.
 
 Clips never routes recording/meeting audio to OpenAI for transcription. (Groq's endpoint is OpenAI-_compatible_ in request shape only — the audio goes to Groq, not OpenAI.)
 
 If no native transcript exists and no cloud fallback is available (no Builder connection and no Groq key), the action writes `status="failed"` so the UI can show a friendly prompt.
 
-When a transcript becomes ready, `request-transcript` must await native cleanup
-and the metadata handoff before its durable post-finalize worker returns.
-Do not leave title/summary work as an unawaited promise in that worker:
+When a transcript becomes ready, `request-transcript` must await the metadata
+handoff before its durable post-finalize worker returns. Do not leave
+title/summary work as an unawaited promise in that worker:
 serverless runtimes may freeze it immediately. A local heuristic title uses
 `titleSource: "context"` so it remains a temporary UI fallback until the
 `generate-metadata` agent request replaces it with a transcript-backed title.

package/corpus/templates/clips/.agents/skills/recording/SKILL.md

@@ -15,7 +15,7 @@ Reach for this skill any time you touch the recorder: the record button, the in-
 
 ## Data model touched
 
-- **`recordings`** — the row gets created as soon as the user presses Record or imports a source. Native/file recordings transition `uploading` → `processing` → `ready` (or `failed`). `videoUrl`, `durationMs`, `videoSizeBytes`, `width`, `height`, `hasAudio`, `hasCamera` are populated as the upload streams in. Loom imports use `import-loom-recording` and create a `ready` row whose `videoUrl` is a Loom embed URL.
+- **`recordings`** — the row gets created as soon as the user presses Record or imports a source. Native/file recordings transition `uploading` → `processing` → `ready` (or `failed`). `videoUrl`, `durationMs`, `videoSizeBytes`, `width`, `height`, `hasAudio`, `hasCamera` are populated as the upload streams in. Loom imports use `import-loom-recording` and become ready with either a Clips-hosted MP4 or a Loom embed when MP4 export is unavailable.
 - **`application_state.record-intent`** — the agent writes this when it wants to start a recording. The UI reads and clears it, then prompts for permission.
 - **`application_state.navigation`** — set to `{ view: "record" }` while the recorder is active.
 
@@ -122,13 +122,14 @@ segments; never store Loom's signed CDN URLs.
 When Loom exposes a downloadable public MP4, `import-loom-recording` downloads
 it, reuploads the bytes to Clips storage, and creates a ready, playable
 Clips-hosted recording, importing Loom's public transcript when the share page
-exposes one. If Loom does not expose a downloadable MP4, ask the user to download
-the original from Loom and use "Upload video".
-
-Loom imports are embed-backed, not Clips-owned video files. The player renders a
-Loom iframe and the native Clips editor is hidden for those recordings. If the
-user needs Clips-native trimming, exports, frame extraction, or upload-based
-transcription, ask them to upload the original video file instead.
+exposes one. If Loom allows public playback but does not expose an MP4, the
+action keeps a ready, embed-backed recording and still imports the transcript
+when available.
+
+Embed-backed Loom imports render a Loom iframe and hide the native Clips editor.
+Reuploaded Loom imports support Clips-native trimming, exports, frame extraction,
+and upload-based transcription; ask the user to upload the original video file
+when those capabilities are needed for an embed-backed import.
 
 ## Browser diagnostics and recorder install options
 

package/corpus/templates/clips/actions/import-loom-recording.ts

@@ -145,7 +145,7 @@ async function fetchLoomOembed(shareUrl: string) {
 
 export default defineAction({
   description:
-    "Import a public Loom share URL, or a direct link to a video file, into Clips as a playable recording. Loom links create the recording immediately and download/reupload Loom's public MP4 plus import Loom's public transcript in the background, since Loom's CDN plus a reupload can take longer than a single request should block on. Other direct video links (e.g. an MP4/WebM/MOV hosted by another screen recorder) are downloaded and reuploaded synchronously without transcript metadata — use request-transcript afterward. If storage is not connected, creates a waiting recording that can be retried after storage setup.",
+    "Import a public Loom share URL, or a direct link to a video file, into Clips as a playable recording. Loom links create the recording immediately and download/reupload Loom's public MP4 when available, or keep a playable Loom embed when Loom allows playback but not MP4 export; public transcripts are imported in the background. Other direct video links (e.g. an MP4/WebM/MOV hosted by another screen recorder) are downloaded and reuploaded synchronously without transcript metadata — use request-transcript afterward. If storage is not connected, creates a waiting recording that can be retried after storage setup.",
   schema: ImportLoomRecordingSchema,
   run: async (args, actionContext) => {
     const loomId = extractLoomVideoId(args.url);

package/corpus/templates/clips/actions/lib/loom-import-job.ts

@@ -8,13 +8,14 @@ import { ownerEmailMatches } from "../../server/lib/recordings.js";
 import { transactionalEmailStore } from "../../server/lib/transactional-email-store.js";
 import {
   extractLoomVideoId,
+  loomEmbedUrlForId,
   normalizeLoomShareUrl,
 } from "../../shared/loom.js";
 import {
   fetchLoomTranscript,
   loomTranscriptUnavailableMessage,
 } from "./loom-transcript.js";
-import { downloadLoomVideo } from "./loom-video.js";
+import { downloadLoomVideo, LoomVideoUnavailableError } from "./loom-video.js";
 
 export type LoomImportJobResult = {
   status: "ready" | "failed";
@@ -147,7 +148,7 @@ export async function runLoomImportJob({
 
   console.log("[loom-import] job started", { recordingId, claimId });
 
-  let media: Awaited<ReturnType<typeof downloadLoomVideo>>;
+  let media: Awaited<ReturnType<typeof downloadLoomVideo>> | null = null;
   try {
     media = await downloadLoomVideo({ loomId, shareUrl });
     console.log("[loom-import] download complete", {
@@ -156,40 +157,54 @@ export async function runLoomImportJob({
       mimeType: media.mimeType,
     });
   } catch (err) {
-    return failLoomImport(
-      recordingId,
-      err instanceof Error ? err.message : String(err),
-      claimId,
-    );
+    // Loom's public player can work even when the viewer's role cannot export MP4.
+    if (err instanceof LoomVideoUnavailableError) {
+      console.warn("[loom-import] MP4 unavailable; keeping Loom embed", {
+        recordingId,
+        loomId,
+      });
+    } else {
+      return failLoomImport(
+        recordingId,
+        err instanceof Error ? err.message : String(err),
+        claimId,
+      );
+    }
   }
 
   try {
-    const upload = await uploadFile({
-      data: media.bytes,
-      filename: `${recordingId}.mp4`,
-      mimeType: media.mimeType,
-      ownerEmail,
-      stableUrl: true,
-      recordAsset: false,
-    });
-    if (!upload?.url) {
+    const upload = media
+      ? await uploadFile({
+          data: media.bytes,
+          filename: `${recordingId}.mp4`,
+          mimeType: media.mimeType,
+          ownerEmail,
+          stableUrl: true,
+          recordAsset: false,
+        })
+      : null;
+    if (media && !upload?.url) {
       return failLoomImport(
         recordingId,
         "File upload returned no URL. Check your storage provider configuration.",
         claimId,
       );
     }
-    console.log("[loom-import] reupload complete", {
-      recordingId,
-      videoUrl: upload.url,
-    });
+
+    const videoUrl = upload?.url ?? loomEmbedUrlForId(loomId);
+    if (upload) {
+      console.log("[loom-import] reupload complete", {
+        recordingId,
+        videoUrl: upload.url,
+      });
+    }
 
     const now = new Date().toISOString();
     const [mediaReady] = await db
       .update(schema.recordings)
       .set({
-        videoUrl: upload.url,
-        videoSizeBytes: media.sizeBytes,
+        videoUrl,
+        videoSizeBytes: media?.sizeBytes ?? 0,
         status: "ready",
         failureReason: null,
         updatedAt: now,
@@ -213,20 +228,22 @@ export async function runLoomImportJob({
     }
     console.log("[loom-import] recording ready", { recordingId });
 
-    void queueBuilderMediaCompression({
-      recordingId,
-      ownerEmail,
-      videoUrl: upload.url,
-      mimeType: media.mimeType,
-      providerId: upload.provider,
-      assetDbId: upload.id,
-      sourceSizeBytes: media.sizeBytes,
-    }).catch((err) => {
-      console.warn("[clips] Loom media compression queue failed", {
+    if (media && upload) {
+      void queueBuilderMediaCompression({
         recordingId,
-        error: err instanceof Error ? err.message : String(err),
+        ownerEmail,
+        videoUrl: upload.url,
+        mimeType: media.mimeType,
+        providerId: upload.provider,
+        assetDbId: upload.id,
+        sourceSizeBytes: media.sizeBytes,
+      }).catch((err) => {
+        console.warn("[clips] Loom media compression queue failed", {
+          recordingId,
+          error: err instanceof Error ? err.message : String(err),
+        });
       });
-    });
+    }
 
     try {
       let transcript: Awaited<ReturnType<typeof fetchLoomTranscript>> = null;
@@ -291,7 +308,7 @@ export async function runLoomImportJob({
         recordingId,
         status: "ready",
         progress: 100,
-        videoUrl: upload.url,
+        videoUrl,
         updatedAt: now,
       });
       await writeAppState("refresh-signal", { ts: Date.now() });

package/corpus/templates/clips/actions/request-transcript.ts

@@ -38,8 +38,6 @@ import {
 } from "@agent-native/core/application-state";
 import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
 import { resolveHasBuilderPrivateKey } from "@agent-native/core/server";
-import { getRequestUserEmail } from "@agent-native/core/server/request-context";
-import { getSetting, getUserSetting } from "@agent-native/core/settings";
 import { assertAccess } from "@agent-native/core/sharing";
 import { transcribeWithBuilder } from "@agent-native/core/transcription/builder";
 import { and, eq } from "drizzle-orm";
@@ -66,8 +64,6 @@ import {
   type TranscriptSegment,
 } from "../shared/transcript-segments.js";
 import { PENDING_TRANSCRIPT_HEARTBEAT_MS } from "../shared/transcript-status.js";
-import cleanupTranscript from "./cleanup-transcript.js";
-import { loadAgentsMdContext } from "./lib/agents-md-context.js";
 import {
   AudioOnlyExtractionError,
   assertAudioHasAudibleSignal,
@@ -107,7 +103,6 @@ type RecordingMediaRow = {
 const BUILDER_GEMINI_TRANSCRIPTION_MODEL = "gemini-3-1-flash-lite";
 const SPEECH_ONLY_TRANSCRIPTION_INSTRUCTIONS =
   "Auto-detect the spoken language from the audio. Transcribe only words spoken in the audio, in the same language they were spoken. Do not translate. Do not infer language from screen text, filenames, account settings, browser locale, or these instructions. Do not describe screen activity, UI changes, silence, music, or non-speech sounds. Return an empty transcript when there are no spoken words.";
-const CLIPS_USER_PREFS_KEY = "clips-user-prefs";
 const RECENT_PENDING_TRANSCRIPT_MS = 2 * 60 * 1000;
 const BUILDER_TRANSCRIPTION_MIN_TIMEOUT_MS = 45_000;
 const BUILDER_TRANSCRIPTION_MAX_TIMEOUT_MS = 65_000;
@@ -856,27 +851,11 @@ async function failAudioOnlyPreparation({
   throw new Error(reason);
 }
 
-async function transcriptCleanupEnabled(): Promise<boolean> {
-  const userEmail = getRequestUserEmail();
-  if (userEmail) {
-    const userSettings = await getUserSetting(
-      userEmail,
-      CLIPS_USER_PREFS_KEY,
-    ).catch(() => null);
-    if (userSettings && "transcriptCleanupEnabled" in userSettings) {
-      return userSettings.transcriptCleanupEnabled !== false;
-    }
-  }
-
-  const settings = await getSetting(CLIPS_USER_PREFS_KEY).catch(() => null);
-  return settings?.transcriptCleanupEnabled !== false;
-}
-
 /**
  * Read the language already detected/stored on this recording's transcript row.
- * Cleanup and renormalization must preserve a detected non-English language
- * rather than clobbering it back to "en". Falls back to "en" only when no row
- * (or no language) exists yet.
+ * Renormalization must preserve a detected non-English language rather than
+ * clobbering it back to "en". Falls back to "en" only when no row (or no
+ * language) exists yet.
  */
 async function resolveStoredLanguage(
   db: ReturnType<typeof getDb>,
@@ -890,140 +869,6 @@ async function resolveStoredLanguage(
   return row?.language?.trim() || "en";
 }
 
-async function cleanupNativeTranscript({
-  db,
-  recordingId,
-  ownerEmail,
-  fullText,
-  durationMs,
-  segmentsJson,
-}: {
-  db: ReturnType<typeof getDb>;
-  recordingId: string;
-  ownerEmail: string;
-  fullText: string;
-  durationMs: number | null | undefined;
-  segmentsJson?: string | null;
-}): Promise<{ cleaned: boolean; provider?: string }> {
-  const sourceText = fullText.trim();
-  if (!sourceText) return { cleaned: false };
-
-  if (!(await transcriptCleanupEnabled())) {
-    await writeTranscriptCleanupState(recordingId, {
-      status: "disabled",
-    });
-    return { cleaned: false };
-  }
-
-  await writeTranscriptCleanupState(recordingId, {
-    status: "running",
-    provider: BUILDER_GEMINI_TRANSCRIPTION_MODEL,
-    startedAt: new Date().toISOString(),
-  });
-
-  try {
-    const agentsContext = await loadAgentsMdContext({
-      ownerEmail,
-      purpose: "cleanup",
-    });
-    const result = await cleanupTranscript.run({
-      transcript: sourceText,
-      task: "cleanup",
-      context: agentsContext,
-    });
-    const cleanedText = result.cleanedText?.trim();
-    if (!cleanedText || cleanedText === sourceText) {
-      await writeTranscriptCleanupState(recordingId, {
-        status: "unchanged",
-        provider: result.provider,
-      });
-      return { cleaned: false, provider: result.provider };
-    }
-    if (!isSafeTranscriptCleanupReplacement(sourceText, cleanedText)) {
-      await writeTranscriptCleanupState(recordingId, {
-        status: "failed",
-        provider: result.provider,
-        failureReason:
-          "Cleanup output was incomplete; the original transcript was kept.",
-        sourceChars: sourceText.length,
-        cleanedChars: cleanedText.length,
-      });
-      return { cleaned: false, provider: result.provider };
-    }
-
-    const cleanupSegmentsJson = resolveCleanupSegmentsJson(
-      segmentsJson,
-      cleanedText,
-      durationMs,
-    );
-    if (!cleanupSegmentsJson) {
-      await writeTranscriptCleanupState(recordingId, {
-        status: "unchanged",
-        provider: result.provider,
-        failureReason:
-          "Cleanup output could not be aligned with measured speaker cues; the original transcript was kept.",
-      });
-      return { cleaned: false, provider: result.provider };
-    }
-
-    const now = new Date().toISOString();
-    const language = await resolveStoredLanguage(db, recordingId);
-    const updated = await db
-      .update(schema.recordingTranscripts)
-      .set({
-        ownerEmail,
-        status: "ready",
-        failureReason: null,
-        language,
-        segmentsJson: cleanupSegmentsJson,
-        fullText: cleanedText,
-        retryCount: 0,
-        updatedAt: now,
-      })
-      .where(
-        and(
-          eq(schema.recordingTranscripts.recordingId, recordingId),
-          eq(schema.recordingTranscripts.status, "ready"),
-          eq(schema.recordingTranscripts.fullText, sourceText),
-        ),
-      )
-      .returning({ recordingId: schema.recordingTranscripts.recordingId });
-    if (!updated.length) {
-      await writeTranscriptCleanupState(recordingId, {
-        status: "failed",
-        provider: result.provider,
-        failureReason:
-          "Transcript changed during cleanup; the newer transcript was kept.",
-      });
-      return { cleaned: false, provider: result.provider };
-    }
-    await writeTranscriptCleanupState(recordingId, {
-      status: "ready",
-      provider: result.provider,
-    });
-
-    return { cleaned: true, provider: result.provider };
-  } catch (err) {
-    const details = serializeError(err);
-    console.warn(
-      `[clips] native transcript cleanup skipped for ${recordingId}: ${summarizeError(err)}`,
-    );
-    if (verboseTranscriptErrors()) {
-      console.warn(
-        "[clips] native transcript cleanup error details",
-        serializeError(err, { includeStack: true }),
-      );
-    }
-    await writeTranscriptCleanupState(recordingId, {
-      status: "failed",
-      provider: BUILDER_GEMINI_TRANSCRIPTION_MODEL,
-      failureReason: (err as Error)?.message ?? String(err),
-      details,
-    });
-    return { cleaned: false };
-  }
-}
-
 async function generateRecordingMetadata({
   recordingId,
   title,
@@ -1120,21 +965,6 @@ async function completeReadyTranscript({
     }
   }
 
-  const cleanupPromise = cleanupNativeTranscript({
-    db,
-    recordingId,
-    ownerEmail,
-    fullText,
-    durationMs: recForTitle?.durationMs,
-    segmentsJson,
-  }).catch((err) => {
-    console.warn(
-      `[clips] native transcript cleanup failed for ${recordingId}:`,
-      (err as Error)?.message ?? String(err),
-    );
-    return { cleaned: false };
-  });
-
   const metadataPromise = recForTitle
     ? generateRecordingMetadata({
         recordingId,
@@ -1151,12 +981,7 @@ async function completeReadyTranscript({
       })
     : Promise.resolve({ titleQueued: false, summaryQueued: false });
 
-  // Both calls are independent. Await them together so the durable worker stays
-  // alive without serially stacking two model-call timeouts.
-  const [cleanupResult, metadataResult] = await Promise.all([
-    cleanupPromise,
-    metadataPromise,
-  ]);
+  const metadataResult = await metadataPromise;
 
   if (!recForTitle) {
     console.warn(
@@ -1175,9 +1000,7 @@ async function completeReadyTranscript({
     );
   }
 
-  // Wake the player polling so it picks up the queued cleanup state row
-  // (`transcript-cleanup-${recordingId}`) before its next 2s tick lands —
-  // otherwise the "Cleaning up…" badge can lag for one full poll interval.
+  // Wake the player polling after transcript metadata generation completes.
   await writeAppState("refresh-signal", { ts: Date.now() });
   await finalizeEndedMeetingsForRecording(db, recordingId);
   await queueBrainExport(recordingId);
@@ -1185,7 +1008,7 @@ async function completeReadyTranscript({
   return {
     recordingId,
     status: "ready",
-    cleaned: cleanupResult.cleaned,
+    cleaned: false,
     provider: segmentsJson && segmentsJson !== "[]" ? "existing" : "native",
     cleanupQueued: false,
     titleQueued: metadataResult.titleQueued,

package/corpus/templates/clips/app/components/clips-avatar.tsx

@@ -0,0 +1,46 @@
+import {
+  forwardRef,
+  useCallback,
+  type ComponentPropsWithoutRef,
+  type ReactNode,
+} from "react";
+
+import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+import { useVisibleAvatarUrl } from "@/lib/use-visible-avatar-url";
+
+interface ClipsAvatarProps extends Omit<
+  ComponentPropsWithoutRef<typeof Avatar>,
+  "children"
+> {
+  email: string | null | undefined;
+  alt: string;
+  fallback: ReactNode;
+  fallbackClassName?: string;
+}
+
+export const ClipsAvatar = forwardRef<HTMLSpanElement, ClipsAvatarProps>(
+  function ClipsAvatar(
+    { email, alt, fallback, fallbackClassName, ...avatarProps },
+    forwardedRef,
+  ) {
+    const { avatarRef, avatarUrl } = useVisibleAvatarUrl(email);
+    const setAvatarRef = useCallback(
+      (element: HTMLSpanElement | null) => {
+        avatarRef.current = element;
+        if (typeof forwardedRef === "function") forwardedRef(element);
+        else if (forwardedRef) forwardedRef.current = element;
+      },
+      [avatarRef, forwardedRef],
+    );
+
+    return (
+      <Avatar {...avatarProps} ref={setAvatarRef}>
+        {avatarUrl ? <AvatarImage src={avatarUrl} alt={alt} /> : null}
+        <AvatarFallback className={fallbackClassName}>
+          {fallback}
+        </AvatarFallback>
+      </Avatar>
+    );
+  },
+);
+ClipsAvatar.displayName = "ClipsAvatar";

package/corpus/templates/clips/app/components/library/recording-card.tsx

@@ -17,9 +17,9 @@ import {
 import { useCallback, useMemo, useRef, useState } from "react";
 import { Link } from "react-router";
 
+import { ClipsAvatar } from "@/components/clips-avatar";
 import { AgentViewCount } from "@/components/player/recording-views-badge";
 import { ViewedByPopover } from "@/components/sharing/viewed-by-popover";
-import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
 import { Checkbox } from "@/components/ui/checkbox";
 import {
   DropdownMenu,
@@ -340,12 +340,13 @@ export function RecordingCard({
               </div>
             )}
             <div className="mt-1 flex min-w-0 items-center gap-1.5 text-[11px] text-muted-foreground">
-              <Avatar className="h-4 w-4 shrink-0">
-                <AvatarImage src="" alt={recording.ownerEmail} />
-                <AvatarFallback className="bg-primary/15 text-[8px] text-primary">
-                  {ownerInitials}
-                </AvatarFallback>
-              </Avatar>
+              <ClipsAvatar
+                email={recording.ownerEmail}
+                alt={recording.ownerEmail}
+                fallback={ownerInitials}
+                className="h-4 w-4 shrink-0"
+                fallbackClassName="bg-primary/15 text-[8px] text-primary"
+              />
               <span className="min-w-0 truncate">{recording.ownerEmail}</span>
               <span aria-hidden>•</span>
               <span className="shrink-0">{relative}</span>

package/corpus/templates/clips/app/components/library/space-card.tsx

@@ -9,6 +9,7 @@ import {
 import { useState } from "react";
 import { Link } from "react-router";
 
+import { ClipsAvatar } from "@/components/clips-avatar";
 import {
   ContextMenu,
   ContextMenuContent,
@@ -104,13 +105,15 @@ export function SpaceCard({
                       .slice(0, 2)
                       .toUpperCase();
                     return (
-                      <div
+                      <ClipsAvatar
                         key={email}
+                        email={email}
+                        alt={email}
+                        fallback={initials}
+                        className="h-5 w-5 border border-background"
+                        fallbackClassName="bg-primary/15 text-[9px] font-medium text-primary"
                         title={email}
-                        className="flex h-5 w-5 items-center justify-center rounded-full border border-background bg-primary/15 text-[9px] font-medium text-primary"
-                      >
-                        {initials}
-                      </div>
+                      />
                     );
                   })}
                   {members.length > 5 && (

package/corpus/templates/clips/app/components/meetings/attendee-stack.tsx

@@ -5,7 +5,7 @@
  * gets a shadcn Tooltip showing name/email. Used on both list cards and
  * detail headers.
  */
-import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+import { ClipsAvatar } from "@/components/clips-avatar";
 import {
   Tooltip,
   TooltipContent,
@@ -58,14 +58,13 @@ export function AttendeeStack({
         {visible.map((p, i) => (
           <Tooltip key={`${p.email}-${i}`}>
             <TooltipTrigger asChild>
-              <Avatar
+              <ClipsAvatar
+                email={p.email}
+                alt={p.name || p.email}
+                fallback={attendeeInitials(p)}
+                fallbackClassName="font-medium"
                 className={`${sizeClass} ring-2 ring-background cursor-default`}
-              >
-                <AvatarImage alt={p.name || p.email} />
-                <AvatarFallback className="font-medium">
-                  {attendeeInitials(p)}
-                </AvatarFallback>
-              </Avatar>
+              />
             </TooltipTrigger>
             <TooltipContent side="top" className="text-xs">
               <div className="font-medium">{p.name || p.email}</div>