@agent-native/core 0.196.0 → 0.196.1-nightly-20260928204657

package/corpus/templates/clips/app/hooks/use-auto-title.ts

@@ -8,46 +8,36 @@ import {
   bumpChangeVersion,
   callAction,
   getChangeVersion,
-  useChangeVersions,
+  useActionQuery,
+  useChangeVersion,
 } from "@agent-native/core/client/hooks";
 import {
   aiRequestTabId,
   parseAiRequestTabId,
+  type AutoTitleCandidate,
   type ClipsAiRequestKind,
 } from "@shared/ai-request-status";
 import { fullVideoAiModelSelection } from "@shared/clips-ai-prefs";
 import { useEffect, useRef } from "react";
 
-import { useRecordings, type RecordingSummary } from "./use-library";
-
-const DEFAULT_TITLE = "Untitled recording";
 const TWO_MINUTES_MS = 2 * 60 * 1000;
 export const WORKFLOW_ACTION_MAX_ATTEMPTS = 5;
 const WORKFLOW_ACTION_RETRY_DELAY_MS = 1000;
-const AI_REQUEST_SOURCE_PREFIX = "app-state:clips-ai-request-";
+// `queueAiRequest` publishes `refresh-signal` after every queue, whoever the
+// writer is. Sync drops this tab's own events, so local queues bump it too.
+const AI_REQUEST_REFRESH_SOURCE = "app-state:refresh-signal";
 const AI_REQUEST_DELIVERY_TIMEOUT_MS = 10_000;
 
-export function notifyAiRequestQueued(recordingId: string): void {
-  if (!recordingId) return;
-  const source = `${AI_REQUEST_SOURCE_PREFIX}${recordingId}`;
-  bumpChangeVersion(source, Math.max(Date.now(), getChangeVersion(source) + 1));
-}
-
-export function isDefaultTitle(title: string | null | undefined): boolean {
-  const trimmed = (title ?? "").trim();
-  if (!trimmed) return true;
-  return trimmed === DEFAULT_TITLE;
+function bumpAiRequestRefresh(): void {
+  bumpChangeVersion(
+    AI_REQUEST_REFRESH_SOURCE,
+    Math.max(Date.now(), getChangeVersion(AI_REQUEST_REFRESH_SOURCE) + 1),
+  );
 }
 
-export function isAutoTitleReplaceable(
-  title: string | null | undefined,
-  titleSource: string | null | undefined,
-): boolean {
-  return (
-    isDefaultTitle(title) ||
-    titleSource === "default" ||
-    titleSource === "context"
-  );
+export function notifyAiRequestQueued(recordingId: string): void {
+  if (!recordingId) return;
+  bumpAiRequestRefresh();
 }
 
 interface AiRequest {
@@ -70,6 +60,13 @@ interface AiRequest {
   deliveredTabId?: string;
 }
 
+type QueuedAiRequest = AiRequest & { recordingId: string };
+
+interface ListAiRequestsResult {
+  requests: QueuedAiRequest[];
+  titleCandidates: AutoTitleCandidate[];
+}
+
 const DISPATCHABLE_REQUESTS = new Set([
   "generate-metadata",
   "regenerate-title",
@@ -80,23 +77,6 @@ const DISPATCHABLE_REQUESTS = new Set([
   "generate-workflow",
 ]);
 
-async function listRequests(): Promise<Map<string, AiRequest>> {
-  try {
-    const result = (await callAction("list-ai-requests", {} as any, {
-      method: "GET",
-    })) as { requests?: AiRequest[] } | null | undefined;
-    return new Map(
-      (result?.requests ?? [])
-        .filter(
-          (r): r is AiRequest & { recordingId: string } => !!r?.recordingId,
-        )
-        .map((r) => [r.recordingId, r]),
-    );
-  } catch {
-    return new Map();
-  }
-}
-
 async function clearRequest(recordingId: string): Promise<void> {
   const url = agentNativePath(
     `/_agent-native/application-state/${encodeURIComponent(
@@ -104,11 +84,15 @@ async function clearRequest(recordingId: string): Promise<void> {
     )}`,
   );
   await fetch(url, { method: "DELETE" }).catch(() => {});
+  bumpAiRequestRefresh();
 }
 
 export function useAutoTitleBridge(): void {
-  const { data } = useRecordings({ view: "all", limit: 200 });
-  const recordings: RecordingSummary[] = data?.recordings ?? [];
+  const { data, refetch } = useActionQuery<ListAiRequestsResult>(
+    "list-ai-requests",
+    {} as any,
+  );
+  const refreshVersion = useChangeVersion(AI_REQUEST_REFRESH_SOURCE);
   const dispatched = useRef<Set<string>>(new Set());
   const inflight = useRef<boolean>(false);
 
@@ -157,163 +141,158 @@ export function useAutoTitleBridge(): void {
       window.removeEventListener("agentNative.chatRunning", handleChatRunning);
   }, []);
 
-  const readyRecordings = recordings.filter((r) => r.status === "ready");
-  const readyRecordingsKey = readyRecordings
-    .map(
-      (r) =>
-        `${r.id}:${r.titleSource ?? ""}:${r.title}:${r.updatedAt}:${r.transcriptStatus ?? ""}:${r.transcriptHasText ? "1" : "0"}`,
-    )
-    .join("|");
-  const aiRequestVersion = useChangeVersions(
-    readyRecordings.map(
-      (recording) => `app-state:clips-ai-request-${recording.id}`,
-    ),
-  );
+  useEffect(() => {
+    if (refreshVersion) void refetch();
+  }, [refreshVersion, refetch]);
 
   useEffect(() => {
-    if (readyRecordings.length === 0) return;
+    if (!data) return;
     let cancelled = false;
-    let fallbackTimer: ReturnType<typeof setTimeout> | null = null;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    function retrySoon() {
+      timer = setTimeout(() => {
+        void refetch().then((result) => {
+          if (!cancelled && result.data) void deliver(result.data);
+        });
+      }, 1000);
+    }
 
-    async function tick() {
+    async function deliver(snapshot: ListAiRequestsResult) {
       if (cancelled) return;
       if (inflight.current) {
-        fallbackTimer = setTimeout(() => void tick(), 50);
+        timer = setTimeout(() => void deliver(snapshot), 50);
         return;
       }
       inflight.current = true;
       try {
-        const requestsById = await listRequests();
-        if (cancelled) return;
-
-        for (const rec of readyRecordings) {
+        const pending = new Set<string>();
+        for (const request of snapshot.requests) {
           if (cancelled) return;
+          if (!request.kind || !DISPATCHABLE_REQUESTS.has(request.kind)) {
+            continue;
+          }
+          pending.add(request.recordingId);
+          const dispatchKey = `${request.recordingId}:${request.kind}:${
+            request.requestId ?? request.requestedAt ?? "0"
+          }`;
+          if (dispatched.current.has(dispatchKey)) continue;
+          if (
+            request.kind === "generate-metadata" ||
+            request.kind === "regenerate-title"
+          ) {
+            dispatched.current.add(fallbackKey(request.recordingId));
+          }
 
-          const request = requestsById.get(rec.id) ?? null;
-
-          if (request?.kind && DISPATCHABLE_REQUESTS.has(request.kind)) {
-            const dispatchKey = `${rec.id}:${request.kind}:${
-              request.requestId ?? request.requestedAt ?? "0"
-            }`;
-            if (dispatched.current.has(dispatchKey)) continue;
-            if (
-              request.kind === "generate-metadata" ||
-              request.kind === "regenerate-title"
-            ) {
-              dispatched.current.add(`${rec.id}:fallback`);
-            }
-
-            if (
-              request.kind === "generate-workflow" &&
-              typeof request.requestedAt === "string"
-            ) {
-              const workflowRequest = {
-                recordingId: rec.id,
-                requestedAt: request.requestedAt,
-                ...(request.requestId ? { requestId: request.requestId } : {}),
-              };
-              if (request.deliveredTabId) {
-                dispatched.current.add(dispatchKey);
-                void consumeWorkflowRequest({
-                  ...workflowRequest,
-                  tabId: request.deliveredTabId,
-                });
-                continue;
-              }
-
-              const tabId = workflowTabId(
-                rec.id,
-                request.requestedAt,
-                request.requestId,
-              );
-              try {
-                const result = (await callAction(
-                  "reconcile-workflow-generation" as any,
-                  {
-                    operation: "track",
-                    ...workflowRequest,
-                    tabId,
-                  } as any,
-                )) as { tracked?: boolean };
-                if (result.tracked !== true) {
-                  fallbackTimer = setTimeout(() => void tick(), 1000);
-                  continue;
-                }
-              } catch {
-                fallbackTimer = setTimeout(() => void tick(), 1000);
-                continue;
-              }
-              const delivery = await sendToAgentChatAndConfirm({
-                ...buildAiRequestChatOptions(rec, request),
-                tabId,
-                chatTarget: "local",
-              });
-              if (!delivery.delivered) {
-                await retryWorkflowAction(
-                  {
-                    operation: "release",
-                    ...workflowRequest,
-                    tabId,
-                  },
-                  "released",
-                );
-                fallbackTimer = setTimeout(() => void tick(), 1000);
-                continue;
-              }
+          if (
+            request.kind === "generate-workflow" &&
+            typeof request.requestedAt === "string"
+          ) {
+            const workflowRequest = {
+              recordingId: request.recordingId,
+              requestedAt: request.requestedAt,
+              ...(request.requestId ? { requestId: request.requestId } : {}),
+            };
+            if (request.deliveredTabId) {
               dispatched.current.add(dispatchKey);
-              void persistAndConsumeWorkflowRequest({
+              void consumeWorkflowRequest({
                 ...workflowRequest,
-                tabId,
+                tabId: request.deliveredTabId,
               });
               continue;
             }
-            if (
-              typeof request.requestedAt !== "string" ||
-              !request.requestedAt.trim()
-            ) {
-              console.warn("[clips] queued AI request is missing requestedAt", {
-                recordingId: rec.id,
-                kind: request.kind,
-              });
-              fallbackTimer = setTimeout(() => void tick(), 1000);
+
+            const tabId = workflowTabId(
+              request.recordingId,
+              request.requestedAt,
+              request.requestId,
+            );
+            try {
+              const result = (await callAction(
+                "reconcile-workflow-generation" as any,
+                {
+                  operation: "track",
+                  ...workflowRequest,
+                  tabId,
+                } as any,
+              )) as { tracked?: boolean };
+              if (result.tracked !== true) {
+                retrySoon();
+                continue;
+              }
+            } catch {
+              retrySoon();
               continue;
             }
-            const delivery = await dispatchAiRequest(
-              rec,
-              request,
-              aiRequestTabId(
-                rec.id,
-                request.kind as ClipsAiRequestKind,
-                request.requestedAt,
-              ),
-            );
+            const delivery = await sendToAgentChatAndConfirm({
+              ...buildAiRequestChatOptions(request),
+              tabId,
+              chatTarget: "local",
+            });
             if (!delivery.delivered) {
-              dispatched.current.delete(dispatchKey);
-              fallbackTimer = setTimeout(() => void tick(), 1000);
+              await retryWorkflowAction(
+                {
+                  operation: "release",
+                  ...workflowRequest,
+                  tabId,
+                },
+                "released",
+              );
+              retrySoon();
               continue;
             }
             dispatched.current.add(dispatchKey);
-            void clearRequest(rec.id);
-          } else if (isAutoTitleReplaceable(rec.title, rec.titleSource)) {
-            if (
-              rec.transcriptStatus !== "ready" ||
-              rec.transcriptHasText !== true
-            ) {
-              continue;
-            }
-
-            if (Date.now() - new Date(rec.createdAt).getTime() < TWO_MINUTES_MS)
-              continue;
-
-            const fallbackKey = `${rec.id}:fallback`;
-            if (dispatched.current.has(fallbackKey)) continue;
-            dispatched.current.add(fallbackKey);
+            void persistAndConsumeWorkflowRequest({
+              ...workflowRequest,
+              tabId,
+            });
+            continue;
+          }
+          if (
+            typeof request.requestedAt !== "string" ||
+            !request.requestedAt.trim()
+          ) {
+            console.warn("[clips] queued AI request is missing requestedAt", {
+              recordingId: request.recordingId,
+              kind: request.kind,
+            });
+            retrySoon();
+            continue;
+          }
+          const delivery = await dispatchAiRequest(
+            request,
+            aiRequestTabId(
+              request.recordingId,
+              request.kind as ClipsAiRequestKind,
+              request.requestedAt,
+            ),
+          );
+          if (!delivery.delivered) {
+            dispatched.current.delete(dispatchKey);
+            retrySoon();
+            continue;
+          }
+          dispatched.current.add(dispatchKey);
+          void clearRequest(request.recordingId);
+        }
 
-            callAction(
-              "regenerate-title" as any,
-              { recordingId: rec.id } as any,
-            ).catch(() => {});
+        for (const candidate of snapshot.titleCandidates) {
+          if (cancelled) return;
+          if (pending.has(candidate.id)) continue;
+          if (autoTitleFallbackDelay(candidate, dispatched.current) !== 0) {
+            continue;
           }
+          dispatched.current.add(fallbackKey(candidate.id));
+          callAction(
+            "regenerate-title" as any,
+            { recordingId: candidate.id } as any,
+          )
+            .then((result) => {
+              if ((result as { queued?: boolean } | null)?.queued === true) {
+                bumpAiRequestRefresh();
+              }
+            })
+            .catch(() => {});
         }
       } finally {
         inflight.current = false;
@@ -321,66 +300,67 @@ export function useAutoTitleBridge(): void {
     }
 
     function scheduleNextFallback() {
-      if (cancelled) return;
+      if (cancelled || !data) return;
       const delay = nextAutoTitleFallbackDelay(
-        readyRecordings,
+        data.titleCandidates,
         dispatched.current,
       );
       if (delay === null) return;
-      fallbackTimer = setTimeout(
+      timer = setTimeout(
         () => {
-          fallbackTimer = null;
-          void tick().finally(scheduleNextFallback);
+          timer = null;
+          void deliver(data).finally(scheduleNextFallback);
         },
         Math.max(delay, 50),
       );
     }
 
-    void tick().finally(scheduleNextFallback);
+    void deliver(data).finally(scheduleNextFallback);
     return () => {
       cancelled = true;
-      if (fallbackTimer) clearTimeout(fallbackTimer);
+      if (timer) clearTimeout(timer);
     };
-    // readyRecordingsKey is the stable snapshot consumed by tick; depending on
-    // the array itself would restart the effect on every query result object.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [aiRequestVersion, readyRecordingsKey]);
+  }, [data, refetch]);
+}
+
+function fallbackKey(recordingId: string): string {
+  return `${recordingId}:fallback`;
+}
+
+/**
+ * Milliseconds until the auto-title fallback may run for this candidate, or
+ * `null` once it has been dispatched. Eligibility is decided by the server.
+ */
+function autoTitleFallbackDelay(
+  candidate: AutoTitleCandidate,
+  dispatched: ReadonlySet<string>,
+  now = Date.now(),
+): number | null {
+  if (dispatched.has(fallbackKey(candidate.id))) return null;
+  const createdAt = new Date(candidate.createdAt).getTime();
+  return Number.isFinite(createdAt)
+    ? Math.max(0, TWO_MINUTES_MS - (now - createdAt))
+    : 0;
 }
 
 export function nextAutoTitleFallbackDelay(
-  recordings: readonly RecordingSummary[],
+  candidates: readonly AutoTitleCandidate[],
   dispatched: ReadonlySet<string>,
   now = Date.now(),
 ): number | null {
   let nextDelay: number | null = null;
-
-  for (const recording of recordings) {
-    if (recording.status !== "ready") continue;
-    if (!isAutoTitleReplaceable(recording.title, recording.titleSource)) {
-      continue;
-    }
-    if (
-      recording.transcriptStatus !== "ready" ||
-      recording.transcriptHasText !== true ||
-      dispatched.has(`${recording.id}:fallback`)
-    ) {
-      continue;
-    }
-
-    const createdAt = new Date(recording.createdAt).getTime();
-    const delay = Number.isFinite(createdAt)
-      ? Math.max(0, TWO_MINUTES_MS - (now - createdAt))
-      : 0;
+  for (const candidate of candidates) {
+    const delay = autoTitleFallbackDelay(candidate, dispatched, now);
+    if (delay === null) continue;
     nextDelay = nextDelay === null ? delay : Math.min(nextDelay, delay);
   }
-
   return nextDelay;
 }
 
-function buildRequestContext(rec: RecordingSummary, request: AiRequest) {
+function buildRequestContext(request: QueuedAiRequest) {
   return {
-    recordingId: rec.id,
-    currentTitle: request.currentTitle ?? rec.title,
+    recordingId: request.recordingId,
+    currentTitle: request.currentTitle ?? "",
     currentDescription: request.currentDescription ?? "",
     transcript: request.transcriptText ?? "",
     agentsContext: request.agentsContext ?? "",
@@ -393,8 +373,7 @@ function buildRequestContext(rec: RecordingSummary, request: AiRequest) {
 }
 
 export function buildAiRequestChatOptions(
-  rec: RecordingSummary,
-  request: AiRequest,
+  request: QueuedAiRequest,
 ): AgentChatMessage {
   const includeFullVideo = request.includeFullVideoInAi === true;
   const gemini = includeFullVideo ? fullVideoAiModelSelection() : null;
@@ -402,8 +381,8 @@ export function buildAiRequestChatOptions(
   return {
     message:
       request.message ??
-      `Handle queued ${request.kind} work for recording ${rec.id}.`,
-    context: JSON.stringify(buildRequestContext(rec, request)),
+      `Handle queued ${request.kind} work for recording ${request.recordingId}.`,
+    context: JSON.stringify(buildRequestContext(request)),
     submit: true,
     openSidebar: openInChat ? true : false,
     newTab: true,
@@ -491,14 +470,10 @@ function requestIdFromTab(tabId: string) {
   return match ? decodeURIComponent(match[1]) : undefined;
 }
 
-function dispatchAiRequest(
-  rec: RecordingSummary,
-  request: AiRequest,
-  tabId: string,
-) {
+function dispatchAiRequest(request: QueuedAiRequest, tabId: string) {
   return sendToAgentChatAndConfirm(
     {
-      ...buildAiRequestChatOptions(rec, request),
+      ...buildAiRequestChatOptions(request),
       chatTarget: "local",
       tabId,
     },

package/corpus/templates/clips/app/routes/_app.r.$recordingId.tsx

@@ -43,6 +43,7 @@ import {
   buildShareContinuationQuery,
   CLIP_SHARE_REF,
 } from "@shared/share-attribution";
+import { isDefaultTitle } from "@shared/title-source";
 import type { WorkflowKind } from "@shared/workflow";
 import {
   IconCalendar,
@@ -141,7 +142,7 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { isDefaultTitle, notifyAiRequestQueued } from "@/hooks/use-auto-title";
+import { notifyAiRequestQueued } from "@/hooks/use-auto-title";
 import { useCompletionAudioCue } from "@/hooks/use-completion-audio-cue";
 import { useFolders, useSpaces } from "@/hooks/use-library";
 import { usePlayerShortcuts } from "@/hooks/use-player-shortcuts";

package/corpus/templates/clips/app/routes/share.$shareId.tsx

@@ -18,6 +18,7 @@ import {
   EnvironmentBadge,
 } from "@agent-native/core/client/ui";
 import { usePersistentSidebarCollapsed } from "@agent-native/toolkit/app-shell";
+import { isDefaultTitle } from "@shared/title-source";
 import {
   IconAlertTriangle,
   IconDeviceDesktop,
@@ -108,7 +109,6 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { isDefaultTitle } from "@/hooks/use-auto-title";
 import { usePlayerShortcuts } from "@/hooks/use-player-shortcuts";
 import { useSonnerLifecycleToast } from "@/hooks/use-sonner-lifecycle-toast";
 import { useViewTracking } from "@/hooks/use-view-tracking";

package/corpus/templates/clips/changelog/2026-09-28-clip-share-previews-show-a-branded-image-while-the-recording.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-28
+---
+
+Clip share previews show a branded image while the recording thumbnail is unavailable.

package/corpus/templates/clips/server/lib/slack-unfurls.ts

@@ -40,6 +40,7 @@ type SlackUnfurlRecording = {
   expiresAt: string | null;
   videoUrl: string | null;
   sourceAppName: string | null;
+  updatedAt: string | null;
 };
 
 export type SlackVideoBlock = {
@@ -289,6 +290,7 @@ export async function loadSlackVideoBlockForUrl(
       expiresAt: schema.recordings.expiresAt,
       videoUrl: schema.recordings.videoUrl,
       sourceAppName: schema.recordings.sourceAppName,
+      updatedAt: schema.recordings.updatedAt,
     })
     .from(schema.recordings)
     .where(eq(schema.recordings.id, share.id))

package/corpus/templates/clips/server/lib/transactional-email-store.ts

@@ -1,6 +1,16 @@
 import { randomUUID } from "node:crypto";
 
-import { and, asc, eq, inArray, isNull, lte, or, type SQL } from "drizzle-orm";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNull,
+  lte,
+  or,
+  sql,
+  type SQL,
+} from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../db/index.js";
@@ -195,8 +205,12 @@ export type TransactionalEmailConfig = z.infer<
 export type TransactionalEmailJob = z.infer<typeof transactionalEmailJobSchema>;
 export type RecapCopy = z.infer<typeof recapCopySchema>;
 
+const AI_BACKED_TYPES = [
+  "two-clips",
+] as const satisfies readonly TransactionalEmailJob["type"][];
+
 export function isAiBackedType(type: TransactionalEmailJob["type"]): boolean {
-  return type === "two-clips";
+  return (AI_BACKED_TYPES as readonly string[]).includes(type);
 }
 
 export type TransactionalEmailStoreOptions = {
@@ -354,6 +368,31 @@ export function createTransactionalEmailStore(
     ).map(databaseJobToJob);
   }
 
+  async function listAiClaimCandidates(
+    claimantEmail: string,
+  ): Promise<TransactionalEmailJob[]> {
+    const claimant = claimantEmail.trim().toLowerCase();
+    return (
+      await getDb()
+        .select()
+        .from(schema.transactionalEmailJobs)
+        .where(
+          and(
+            inArray(schema.transactionalEmailJobs.state, [
+              "awaiting_ai",
+              "ai_dispatched",
+            ]),
+            inArray(schema.transactionalEmailJobs.type, AI_BACKED_TYPES),
+            or(
+              sql`lower(trim(${schema.transactionalEmailJobs.recipient})) = ${claimant}`,
+              sql`lower(trim(${schema.transactionalEmailJobs.requestedBy})) = ${claimant}`,
+            ),
+          ),
+        )
+        .orderBy(asc(schema.transactionalEmailJobs.createdAt))
+    ).map(databaseJobToJob);
+  }
+
   async function replaceJob(
     job: TransactionalEmailJob,
     condition: SQL | undefined,
@@ -768,6 +807,7 @@ export function createTransactionalEmailStore(
     enqueueOrConvergeFirstImport,
     readJob,
     listJobs,
+    listAiClaimCandidates,
     transition,
     claimAwaitingAi,
     reclaimStaleAiDispatch,