@agent-native/core 0.90.1 → 0.90.3

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

@@ -93,6 +93,51 @@ import {
 import { markPopoverInteractOutside } from "@/lib/popover-click-guard";
 import { shortcutModifierLabel } from "@/lib/utils";
 
+const ZOOM_AFTER_CONNECT_EVENT_ID_KEY = "calendar.zoomAfterConnectEventId";
+const ZOOM_AFTER_CONNECT_MAX_AGE_MS = 10 * 60 * 1000;
+
+function getStoredZoomAfterConnectEventId(): string | null {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = window.sessionStorage.getItem(
+      ZOOM_AFTER_CONNECT_EVENT_ID_KEY,
+    );
+    if (!stored) return null;
+    const parsed = JSON.parse(stored) as {
+      eventId?: unknown;
+      startedAt?: unknown;
+    };
+    if (
+      typeof parsed.eventId === "string" &&
+      typeof parsed.startedAt === "number" &&
+      Date.now() - parsed.startedAt < ZOOM_AFTER_CONNECT_MAX_AGE_MS
+    ) {
+      return parsed.eventId;
+    }
+    window.sessionStorage.removeItem(ZOOM_AFTER_CONNECT_EVENT_ID_KEY);
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function setStoredZoomAfterConnectEventId(eventId: string | null): void {
+  if (typeof window === "undefined") return;
+  try {
+    if (eventId) {
+      window.sessionStorage.setItem(
+        ZOOM_AFTER_CONNECT_EVENT_ID_KEY,
+        JSON.stringify({ eventId, startedAt: Date.now() }),
+      );
+    } else {
+      window.sessionStorage.removeItem(ZOOM_AFTER_CONNECT_EVENT_ID_KEY);
+    }
+  } catch {
+    // Storage can be unavailable in locked-down browsers; in-memory state still
+    // handles the normal popup path.
+  }
+}
+
 function formatDuration(start: string, end: string): string {
   const totalMinutes = differenceInMinutes(parseISO(end), parseISO(start));
   const hours = Math.floor(totalMinutes / 60);
@@ -403,6 +448,9 @@ export function EventDetailPopover({
   const [pendingVideoProvider, setPendingVideoProvider] = useState<
     "meet" | "zoom" | null
   >(null);
+  const [zoomAfterConnectEventId, setZoomAfterConnectEventId] = useState<
+    string | null
+  >(() => getStoredZoomAfterConnectEventId());
   const isOverlay = !!event.overlayEmail;
   const ownerLabel = event.ownerName || event.overlayEmail;
 
@@ -686,45 +734,73 @@ export function EventDetailPopover({
     })();
   }, [event, isDraft, onDraftUpdate, promptGuestNotification, updateEvent]);
 
+  const addZoomToConnectedEvent = useCallback(() => {
+    if (!event.id || updateEvent.isPending) return;
+
+    if (isDraft) {
+      onDraftUpdate?.(event.id, { addZoom: true, addGoogleMeet: false });
+      return;
+    }
+
+    setPendingVideoProvider("zoom");
+    void (async () => {
+      const updates = { addZoom: true };
+      const guestNotification = await promptGuestNotification({
+        event,
+        action: "update",
+        updates,
+      });
+      if (!guestNotification) {
+        setPendingVideoProvider(null);
+        return;
+      }
+      updateEvent.mutate(
+        {
+          id: event.id,
+          accountEmail: event.accountEmail,
+          ...updates,
+          ...guestNotification,
+        },
+        {
+          onSuccess: () => toast(t("eventForm.zoomAdded")),
+          onError: (error) =>
+            toast.error(
+              error instanceof Error
+                ? error.message
+                : t("eventForm.zoomAddFailed"),
+            ),
+          onSettled: () => setPendingVideoProvider(null),
+        },
+      );
+    })();
+  }, [event, isDraft, onDraftUpdate, promptGuestNotification, t, updateEvent]);
+
+  useEffect(() => {
+    if (
+      !zoomStatus.data?.connected ||
+      !zoomAfterConnectEventId ||
+      zoomAfterConnectEventId !== event.id ||
+      updateEvent.isPending
+    ) {
+      return;
+    }
+
+    setZoomAfterConnectEventId(null);
+    setStoredZoomAfterConnectEventId(null);
+    addZoomToConnectedEvent();
+  }, [
+    addZoomToConnectedEvent,
+    event.id,
+    updateEvent.isPending,
+    zoomAfterConnectEventId,
+    zoomStatus.data?.connected,
+  ]);
+
   const handleAddZoom = useCallback(() => {
     if (!event.id || updateEvent.isPending || connectZoom.isPending) return;
 
     if (zoomStatus.data?.connected) {
-      if (isDraft) {
-        onDraftUpdate?.(event.id, { addZoom: true, addGoogleMeet: false });
-        return;
-      }
-      setPendingVideoProvider("zoom");
-      void (async () => {
-        const updates = { addZoom: true };
-        const guestNotification = await promptGuestNotification({
-          event,
-          action: "update",
-          updates,
-        });
-        if (!guestNotification) {
-          setPendingVideoProvider(null);
-          return;
-        }
-        updateEvent.mutate(
-          {
-            id: event.id,
-            accountEmail: event.accountEmail,
-            ...updates,
-            ...guestNotification,
-          },
-          {
-            onSuccess: () => toast(t("eventForm.zoomAdded")),
-            onError: (error) =>
-              toast.error(
-                error instanceof Error
-                  ? error.message
-                  : t("eventForm.zoomAddFailed"),
-              ),
-            onSettled: () => setPendingVideoProvider(null),
-          },
-        );
-      })();
+      addZoomToConnectedEvent();
       return;
     }
 
@@ -733,21 +809,25 @@ export function EventDetailPopover({
       return;
     }
 
+    setZoomAfterConnectEventId(event.id);
+    setStoredZoomAfterConnectEventId(event.id);
     connectZoom.mutate(undefined, {
       onSuccess: () => toast(t("eventForm.zoomConnectionOpened")),
-      onError: (error) =>
+      onError: (error) => {
+        setZoomAfterConnectEventId(null);
+        setStoredZoomAfterConnectEventId(null);
         toast.error(
           error instanceof Error
             ? error.message
             : t("eventForm.zoomConnectFailed"),
-        ),
+        );
+      },
     });
   }, [
+    addZoomToConnectedEvent,
     connectZoom,
     event,
-    isDraft,
-    onDraftUpdate,
-    promptGuestNotification,
+    t,
     updateEvent,
     zoomStatus.data?.configured,
     zoomStatus.data?.connected,

package/corpus/templates/calendar/app/hooks/use-people.ts

@@ -15,6 +15,8 @@ export interface PeopleSearchResponse {
 
 const PEOPLE_CONTACTS_STALE_TIME = 10 * 60_000;
 const PEOPLE_CONTACTS_GC_TIME = 30 * 60_000;
+const PEOPLE_SEARCH_STALE_TIME = 60_000;
+const PEOPLE_SEARCH_GC_TIME = 5 * 60_000;
 
 export const PEOPLE_CONTACTS_QUERY_KEY = [
   "action",
@@ -48,6 +50,42 @@ function matchRank(person: PeopleSearchResult, query: string) {
   return 5;
 }
 
+export function mergePeopleResults(
+  ...groups: Array<PeopleSearchResult[] | undefined>
+) {
+  const people = new Map<string, PeopleSearchResult>();
+
+  for (const group of groups) {
+    for (const person of group ?? []) {
+      const email = person.email.trim();
+      const key = email.toLowerCase();
+      if (!key) continue;
+
+      const existing = people.get(key);
+      if (!existing) {
+        people.set(key, { ...person, email });
+        continue;
+      }
+
+      if (sourceRank(person.source) < sourceRank(existing.source)) {
+        existing.source = person.source;
+      }
+      if (
+        person.name &&
+        person.name !== person.email &&
+        (!existing.name || existing.name === existing.email)
+      ) {
+        existing.name = person.name;
+      }
+      if (!existing.photoUrl && person.photoUrl) {
+        existing.photoUrl = person.photoUrl;
+      }
+    }
+  }
+
+  return Array.from(people.values());
+}
+
 export function filterPeopleResults(
   people: PeopleSearchResult[],
   query: string,
@@ -106,3 +144,20 @@ export function usePeopleContacts(enabled = true) {
     refetchOnWindowFocus: false,
   });
 }
+
+export function usePeopleSearch(query: string, enabled = true) {
+  const q = query.trim();
+  return useQuery({
+    queryKey: ["action", "search-people", { q, scope: "all" }],
+    queryFn: () =>
+      callAction<PeopleSearchResponse>(
+        "search-people",
+        { q, scope: "all" },
+        { method: "GET" },
+      ),
+    enabled: enabled && q.length > 0,
+    staleTime: PEOPLE_SEARCH_STALE_TIME,
+    gcTime: PEOPLE_SEARCH_GC_TIME,
+    refetchOnWindowFocus: false,
+  });
+}

package/corpus/templates/calendar/changelog/2026-07-07-guest-suggestions-now-find-coworkers-from-your-google-worksp.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Guest suggestions now find coworkers from your Google Workspace directory as you type.

package/corpus/templates/calendar/changelog/2026-07-07-zoom-stays-selected-after-connecting-it-from-a-draft-event.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Zoom stays selected after connecting it from a draft event.

package/corpus/templates/clips/actions/create-recording.ts

@@ -111,7 +111,11 @@ export default defineAction({
         await setResumableSession(id, {
           providerId: uploadProvider.id,
           sessionId: session.sessionId,
-          meta: { ...session.meta, skipCompressionWait: true },
+          meta: {
+            ...session.meta,
+            skipCompressionWait: true,
+            recordAsset: false,
+          },
           bytesUploaded: 0,
           lastCommittedIndex: -1,
         });

package/corpus/templates/clips/actions/finalize-recording.ts

@@ -98,6 +98,9 @@ function concatBytes(parts: Uint8Array[]): Uint8Array {
 
 const RECORDING_TOO_LARGE_REASON =
   "Recording is too large to process after automatic compression. Please update the app and try again, or record a shorter clip.";
+const MEDIA_SERVE_VERIFICATION_TIMEOUT_MS = 8_000;
+const MEDIA_SERVE_VERIFICATION_ATTEMPTS = 3;
+const MEDIA_SERVE_VERIFICATION_BACKOFF_MS = 350;
 
 function stateNumber(
   value: Record<string, unknown> | null | undefined,
@@ -124,6 +127,78 @@ const cliBoolean = z.preprocess((value) => {
   return value;
 }, z.boolean());
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function shouldVerifyServedMediaUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+async function responseHasReadableMediaBytes(
+  response: Response,
+): Promise<boolean> {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const body = await response.arrayBuffer().catch(() => new ArrayBuffer(0));
+    return body.byteLength > 0;
+  }
+
+  try {
+    const { value } = await reader.read();
+    return (value?.byteLength ?? 0) > 0;
+  } catch {
+    return false;
+  } finally {
+    await reader.cancel().catch(() => undefined);
+  }
+}
+
+async function verifyServedMediaUrl(videoUrl: string): Promise<void> {
+  if (!shouldVerifyServedMediaUrl(videoUrl)) return;
+
+  let lastFailure = "media URL did not serve readable bytes";
+  for (
+    let attempt = 1;
+    attempt <= MEDIA_SERVE_VERIFICATION_ATTEMPTS;
+    attempt++
+  ) {
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      MEDIA_SERVE_VERIFICATION_TIMEOUT_MS,
+    );
+    try {
+      const response = await fetch(videoUrl, {
+        method: "GET",
+        headers: { Range: "bytes=0-1023" },
+        signal: controller.signal,
+      });
+      const statusOk = response.status === 200 || response.status === 206;
+      if (statusOk && (await responseHasReadableMediaBytes(response))) {
+        return;
+      }
+      lastFailure = `media URL returned HTTP ${response.status}`;
+      if (response.status < 500) break;
+    } catch (err) {
+      lastFailure = err instanceof Error ? err.message : String(err);
+    } finally {
+      clearTimeout(timeout);
+    }
+
+    if (attempt < MEDIA_SERVE_VERIFICATION_ATTEMPTS) {
+      await sleep(MEDIA_SERVE_VERIFICATION_BACKOFF_MS * attempt);
+    }
+  }
+
+  throw new Error(`Upload was stored-but-unservable: ${lastFailure}`);
+}
+
 function queueBackgroundBuilderCompression(args: {
   recordingId: string;
   ownerEmail: string;
@@ -142,6 +217,44 @@ function queueBackgroundBuilderCompression(args: {
   });
 }
 
+async function failStoredButUnservableRecording(params: {
+  id: string;
+  ownerEmail: string;
+  failureReason: string;
+}): Promise<void> {
+  const { id, ownerEmail, failureReason } = params;
+  const now = new Date().toISOString();
+  const db = getDb();
+  await db
+    .update(schema.recordings)
+    .set({
+      status: "failed",
+      failureReason,
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.recordings.id, id),
+        ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+      ),
+    );
+  const uploadStateRaw = await readAppState(`recording-upload-${id}`).catch(
+    () => null,
+  );
+  const uploadState =
+    uploadStateRaw && typeof uploadStateRaw === "object"
+      ? (uploadStateRaw as Record<string, unknown>)
+      : {};
+  await writeAppState(`recording-upload-${id}`, {
+    ...uploadState,
+    recordingId: id,
+    status: "failed",
+    failureReason,
+    updatedAt: now,
+  });
+  await writeAppState("refresh-signal", { ts: Date.now() });
+}
+
 // Flip recording to 'ready', seed transcript row, fire background transcript,
 // emit clip.created. Used by both the resumable and buffered upload paths.
 async function markRecordingReady(params: {
@@ -483,9 +596,21 @@ export default defineAction({
             typeof resumableSession.meta.filename === "string"
               ? resumableSession.meta.filename
               : "",
-            { skipCompressionWait: true },
+            { skipCompressionWait: true, recordAsset: false },
           );
           debugLog("[finalize] resumable upload completed", { id, videoUrl });
+          try {
+            await verifyServedMediaUrl(videoUrl);
+          } catch (err) {
+            const failureReason =
+              err instanceof Error ? err.message : String(err);
+            await failStoredButUnservableRecording({
+              id,
+              ownerEmail,
+              failureReason,
+            });
+            throw err;
+          }
           const result = await markRecordingReady({
             ...readyParams,
             videoUrl,
@@ -580,6 +705,7 @@ export default defineAction({
           })
           .where(eq(schema.recordings.id, id));
         await writeAppState(`recording-upload-${id}`, {
+          ...(uploadState ?? {}),
           recordingId: id,
           status: "failed",
           failureReason,
@@ -841,6 +967,7 @@ export default defineAction({
           mimeType,
           ownerEmail,
           skipCompressionWait: true,
+          recordAsset: false,
         });
       } catch (err) {
         // Capture structured context so a "Builder.io upload failed (500)" can
@@ -993,6 +1120,18 @@ export default defineAction({
         videoUrl: upload.url,
         bytes: uploadData.byteLength,
       });
+      try {
+        await verifyServedMediaUrl(upload.url);
+      } catch (err) {
+        chunkKeysToPurge = [];
+        const failureReason = err instanceof Error ? err.message : String(err);
+        await failStoredButUnservableRecording({
+          id,
+          ownerEmail,
+          failureReason,
+        });
+        throw err;
+      }
       const result = await markRecordingReady({
         ...readyParams,
         // Use the audio-probe-corrected value, not the raw client claim in

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

@@ -297,6 +297,7 @@ export default defineAction({
       mimeType: media.mimeType,
       ownerEmail,
       skipCompressionWait: true,
+      recordAsset: false,
     });
 
     const recordingValues = buildRecordingValues(media.sizeBytes);

package/corpus/templates/clips/actions/lib/ensure-seekable-video.ts

@@ -219,6 +219,7 @@ export async function ensureRecordingSeekable(params: {
     mimeType,
     ownerEmail,
     skipCompressionWait: true,
+    recordAsset: false,
   });
 
   if (!upload?.url) {

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

@@ -123,6 +123,36 @@ 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;
+const BUILDER_TRANSCRIPTION_BASE_TIMEOUT_MS = 30_000;
+const BUILDER_TRANSCRIPTION_PER_MINUTE_MS = 3_000;
+
+function clampTimeoutMs(value: number): number {
+  return Math.max(
+    BUILDER_TRANSCRIPTION_MIN_TIMEOUT_MS,
+    Math.min(BUILDER_TRANSCRIPTION_MAX_TIMEOUT_MS, Math.floor(value)),
+  );
+}
+
+export function builderTranscriptionTimeoutMs(
+  durationMs: number | null | undefined,
+): number {
+  const override = Number(process.env.CLIPS_BUILDER_TRANSCRIPTION_TIMEOUT_MS);
+  if (Number.isFinite(override) && override > 0) {
+    return clampTimeoutMs(override);
+  }
+
+  if (!durationMs || !Number.isFinite(durationMs) || durationMs <= 0) {
+    return BUILDER_TRANSCRIPTION_MIN_TIMEOUT_MS;
+  }
+
+  const durationMinutes = Math.ceil(durationMs / 60_000);
+  return clampTimeoutMs(
+    BUILDER_TRANSCRIPTION_BASE_TIMEOUT_MS +
+      durationMinutes * BUILDER_TRANSCRIPTION_PER_MINUTE_MS,
+  );
+}
 
 // Bounded automatic retry for transient failures (ffmpeg timeout, transient
 // provider network/5xx errors) — NOT for permanent failures like "no audio
@@ -1075,6 +1105,7 @@ const requestTranscriptAction = defineAction({
           model: BUILDER_GEMINI_TRANSCRIPTION_MODEL,
           diarize: false,
           instructions: SPEECH_ONLY_TRANSCRIPTION_INSTRUCTIONS,
+          timeoutMs: builderTranscriptionTimeoutMs(rec.durationMs),
         });
 
         const segments = (builderResult.segments ?? [])

package/corpus/templates/clips/actions/set-thumbnail.ts

@@ -116,6 +116,7 @@ export default defineAction({
           args.filename ??
           `thumb-${args.recordingId}.${mime.split("/")[1] ?? "png"}`,
         ownerEmail,
+        recordAsset: false,
       });
       const url = uploaded?.url ?? args.dataUrl; // fall back to inline storage
       basePatch.thumbnailUrl = url;
@@ -134,6 +135,7 @@ export default defineAction({
         mimeType: mime || "image/gif",
         filename: args.filename ?? `thumb-${args.recordingId}.gif`,
         ownerEmail,
+        recordAsset: false,
       });
       const url = uploaded?.url ?? args.dataUrl;
       basePatch.animatedThumbnailUrl = url;

package/corpus/templates/clips/app/components/library/library-layout.tsx

@@ -361,7 +361,8 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
             <>
               <div className="px-3 py-3">
                 <Button
-                  className="w-full gap-1.5 bg-primary text-primary-foreground shadow-sm hover:bg-primary/90"
+                  className="w-full gap-1.5"
+                  variant="outline"
                   size="sm"
                   asChild
                 >
@@ -563,7 +564,11 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
                   {t("navigation.desktopBody")}
                 </span>
               </div>
-              <CaptureInstallButton size="sm" className="shrink-0">
+              <CaptureInstallButton
+                variant="outline"
+                size="sm"
+                className="shrink-0"
+              >
                 Download
               </CaptureInstallButton>
               <Tooltip>

package/corpus/templates/clips/app/components/library/organization-switcher.tsx

@@ -8,7 +8,7 @@ import {
   IconChevronDown,
   IconCheck,
   IconPlus,
-  IconBuilding,
+  IconUsersGroup,
 } from "@tabler/icons-react";
 import { useState } from "react";
 import { toast } from "sonner";
@@ -86,7 +86,7 @@ export function OrganizationSwitcher({ className }: OrganizationSwitcherProps) {
           </DropdownMenuLabel>
           {orgs.length === 0 && (
             <DropdownMenuItem disabled>
-              <IconBuilding className="h-3.5 w-3.5 me-2" />
+              <IconUsersGroup className="h-3.5 w-3.5 me-2" />
               <span className="text-xs">
                 {t("organizationSwitcher.noOrganizations")}
               </span>

package/corpus/templates/clips/app/components/library/sort-menu.tsx

@@ -25,7 +25,7 @@ export function SortMenu({ value, onChange }: SortMenuProps) {
   return (
     <DropdownMenu>
       <DropdownMenuTrigger asChild>
-        <Button variant="outline" size="sm" className="gap-1.5 h-8">
+        <Button variant="outline" size="sm" className="gap-1.5 h-9">
           <IconArrowsSort className="h-3.5 w-3.5" />
           <span className="text-xs">{LABELS[value]}</span>
         </Button>

package/corpus/templates/clips/app/components/player/scrubber-position.ts

@@ -12,3 +12,12 @@ export function scrubberPositionFromClientX(
   const ratio = rect.width > 0 ? x / rect.width : 0;
   return { ms: Math.floor(ratio * durationMs), x };
 }
+
+export function scrubberFillPercent(
+  currentMs: number,
+  durationMs: number,
+): number {
+  if (!Number.isFinite(currentMs) || !Number.isFinite(durationMs)) return 0;
+  if (durationMs <= 0) return 0;
+  return Math.max(0, Math.min(100, (currentMs / durationMs) * 100));
+}

package/corpus/templates/clips/app/components/player/scrubber.tsx

@@ -2,7 +2,10 @@ import { useMemo, useRef, useState } from "react";
 
 import { cn } from "@/lib/utils";
 
-import { scrubberPositionFromClientX } from "./scrubber-position";
+import {
+  scrubberFillPercent,
+  scrubberPositionFromClientX,
+} from "./scrubber-position";
 
 export interface ScrubberProps {
   currentMs: number;
@@ -35,7 +38,7 @@ export function Scrubber(props: ScrubberProps) {
     | null
   >(null);
 
-  const pct = durationMs > 0 ? (currentMs / durationMs) * 100 : 0;
+  const pct = scrubberFillPercent(currentMs, durationMs);
 
   const recentReactions = useMemo(
     () => (reactions ? reactions.slice(-50) : []),