@agent-native/core 0.102.0 → 0.102.2

package/corpus/templates/clips/actions/disconnect-calendar.ts

@@ -13,10 +13,11 @@ import { writeAppState } from "@agent-native/core/application-state";
 import { deleteAppSecret, readAppSecret } from "@agent-native/core/secrets";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { lockCalendarAccount } from "../server/lib/calendar-event-meetings.js";
 import { revokeToken } from "../server/lib/google-calendar-client.js";
 
 export default defineAction({
@@ -90,15 +91,62 @@ export default defineAction({
       }).catch(() => {});
     }
 
-    // Drop the synced events for this account so the meetings tab clears.
-    await db
-      .delete(schema.calendarEvents)
-      .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+    await db.transaction(async (tx) => {
+      // Materialization takes this same account-row write lock before it
+      // snapshots/claims an event and inserts a meeting. Taking it before
+      // this cleanup snapshot prevents a new unrecorded meeting from being
+      // inserted after the rows below have been inspected.
+      if (!(await lockCalendarAccount(tx, args.id, account.ownerEmail))) {
+        throw new Error(`Calendar account not found: ${args.id}`);
+      }
 
-    // Drop the account row itself.
-    await db
-      .delete(schema.calendarAccounts)
-      .where(eq(schema.calendarAccounts.id, args.id));
+      // Preserve recorded meetings, but hide unrecorded calendar placeholders
+      // tied to this account. Without this cleanup, those materialized rows
+      // stay visible after the account and its event cache are removed.
+      const syncedEvents = await tx
+        .select({
+          id: schema.calendarEvents.id,
+          meetingId: schema.calendarEvents.meetingId,
+        })
+        .from(schema.calendarEvents)
+        .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+      const syncedCalendarEventIds = syncedEvents.map((event) => event.id);
+      const syncedMeetingIds = syncedEvents
+        .map((event) => event.meetingId)
+        .filter((meetingId): meetingId is string => Boolean(meetingId));
+      if (syncedCalendarEventIds.length > 0 || syncedMeetingIds.length > 0) {
+        await tx
+          .update(schema.meetings)
+          .set({ trashedAt: new Date().toISOString() })
+          .where(
+            and(
+              or(
+                syncedMeetingIds.length > 0
+                  ? inArray(schema.meetings.id, syncedMeetingIds)
+                  : undefined,
+                syncedCalendarEventIds.length > 0
+                  ? inArray(
+                      schema.meetings.calendarEventId,
+                      syncedCalendarEventIds,
+                    )
+                  : undefined,
+              )!,
+              isNull(schema.meetings.recordingId),
+              isNull(schema.meetings.trashedAt),
+            ),
+          );
+      }
+
+      // Drop the synced events for this account so the meetings tab clears.
+      await tx
+        .delete(schema.calendarEvents)
+        .where(eq(schema.calendarEvents.calendarAccountId, args.id));
+
+      // Drop the account row itself.
+      await tx
+        .delete(schema.calendarAccounts)
+        .where(eq(schema.calendarAccounts.id, args.id));
+    });
 
     await writeAppState("refresh-signal", { ts: Date.now() });
     return { id: args.id, disconnected: true };

package/corpus/templates/clips/actions/generate-workflow.ts

@@ -15,7 +15,10 @@
  */
 
 import { defineAction } from "@agent-native/core";
-import { writeAppState } from "@agent-native/core/application-state";
+import {
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
@@ -51,6 +54,11 @@ Output markdown.`,
 Keep it concise, warm, and professional.`,
 } as const;
 
+// Actions for the same recording can arrive concurrently when the player and
+// agent both retry a request. Keep the read-check-write/enqueue sequence
+// single-flight within this runtime so only one request can claim generation.
+const workflowGenerationLocks = new Set<string>();
+
 export default defineAction({
   description:
     "Ask the agent to generate a structured workflow doc (pr/sop/ticket/email) from this recording's transcript (and the full video when Include full video is enabled). The agent writes the result to clips-workflow-<recordingId> in application_state.",
@@ -61,71 +69,106 @@ export default defineAction({
   run: async (args) => {
     await assertAccess("recording", args.recordingId, "viewer");
 
-    const db = getDb();
-    const [rec] = await db
-      .select()
-      .from(schema.recordings)
-      .where(eq(schema.recordings.id, args.recordingId))
-      .limit(1);
-    if (!rec) throw new Error(`Recording not found: ${args.recordingId}`);
+    const stateKey = `clips-workflow-${args.recordingId}`;
+    if (workflowGenerationLocks.has(stateKey)) {
+      return {
+        queued: false,
+        duplicate: true,
+        recordingId: args.recordingId,
+        kind: args.kind,
+        stateKey,
+      };
+    }
+    workflowGenerationLocks.add(stateKey);
 
-    const [transcript] = await db
-      .select()
-      .from(schema.recordingTranscripts)
-      .where(eq(schema.recordingTranscripts.recordingId, args.recordingId))
-      .limit(1);
+    try {
+      const db = getDb();
+      const [rec] = await db
+        .select()
+        .from(schema.recordings)
+        .where(eq(schema.recordings.id, args.recordingId))
+        .limit(1);
+      if (!rec) throw new Error(`Recording not found: ${args.recordingId}`);
 
-    const stateKey = `clips-workflow-${args.recordingId}`;
-    const includeFullVideoInAi = await readIncludeFullVideoInAi();
+      const [transcript] = await db
+        .select()
+        .from(schema.recordingTranscripts)
+        .where(eq(schema.recordingTranscripts.recordingId, args.recordingId))
+        .limit(1);
 
-    // Seed the output state with a "generating" placeholder so the UI can show
-    // a loading state immediately.
-    await writeAppState(stateKey, {
-      kind: args.kind,
-      status: "generating",
-      recordingId: args.recordingId,
-      requestedAt: new Date().toISOString(),
-    } as any);
+      const includeFullVideoInAi = await readIncludeFullVideoInAi();
 
-    const baseMessage =
-      `Generate a ${args.kind.toUpperCase()} workflow document from recording ${args.recordingId} ` +
-      `(title: "${rec.title}"). Read the transcript from this request's context. ` +
-      `${KIND_PROMPTS[args.kind]} ` +
-      `Then write the final markdown to application_state key "${stateKey}" as ` +
-      `\`{ kind: "${args.kind}", status: "ready", content: "...", recordingId: "${args.recordingId}" }\`. ` +
-      `Finish by replying in chat with the same generated markdown so the user can read it immediately.`;
+      const existing = await readAppState(stateKey).catch(() => null);
+      if (existing?.status === "generating") {
+        const requestedAt = Date.parse(String(existing.requestedAt ?? ""));
+        const isRecent =
+          !Number.isFinite(requestedAt) ||
+          Date.now() - requestedAt < 10 * 60_000;
+        if (isRecent) {
+          return {
+            queued: false,
+            duplicate: true,
+            recordingId: args.recordingId,
+            kind: existing.kind ?? args.kind,
+            stateKey,
+          };
+        }
+      }
 
-    const request = {
-      kind: "generate-workflow" as const,
-      workflowKind: args.kind,
-      recordingId: args.recordingId,
-      requestedAt: new Date().toISOString(),
-      recordingTitle: rec.title,
-      recordingDescription: rec.description,
-      transcriptStatus: transcript?.status ?? "pending",
-      transcriptText: transcript?.fullText ?? "",
-      stateKey,
-      instructions: KIND_PROMPTS[args.kind],
-      includeFullVideoInAi,
-      message: withFullVideoAiInstructions(
-        baseMessage,
-        args.recordingId,
+      // Seed the output state with a "generating" placeholder so the UI can show
+      // a loading state immediately.
+      await writeAppState(stateKey, {
+        kind: args.kind,
+        status: "generating",
+        recordingId: args.recordingId,
+        requestedAt: new Date().toISOString(),
+      } as any);
+
+      const baseMessage =
+        `Generate a ${args.kind.toUpperCase()} workflow document from recording ${args.recordingId} ` +
+        `(title: "${rec.title}"). Read the transcript from this request's context. ` +
+        `${KIND_PROMPTS[args.kind]} ` +
+        `Then write the final markdown to application_state key "${stateKey}" as ` +
+        `\`{ kind: "${args.kind}", status: "ready", content: "...", recordingId: "${args.recordingId}" }\`. ` +
+        `Finish by replying in chat with the same generated markdown so the user can read it immediately.`;
+
+      const request = {
+        kind: "generate-workflow" as const,
+        workflowKind: args.kind,
+        recordingId: args.recordingId,
+        requestedAt: new Date().toISOString(),
+        recordingTitle: rec.title,
+        recordingDescription: rec.description,
+        transcriptStatus: transcript?.status ?? "pending",
+        transcriptText: transcript?.fullText ?? "",
+        stateKey,
+        instructions: KIND_PROMPTS[args.kind],
         includeFullVideoInAi,
-      ),
-    };
+        message: withFullVideoAiInstructions(
+          baseMessage,
+          args.recordingId,
+          includeFullVideoInAi,
+        ),
+      };
 
-    await writeAppState(`clips-ai-request-${args.recordingId}`, request as any);
-    await writeAppState("refresh-signal", { ts: Date.now() });
+      await writeAppState(
+        `clips-ai-request-${args.recordingId}`,
+        request as any,
+      );
+      await writeAppState("refresh-signal", { ts: Date.now() });
 
-    console.log(
-      `Delegation queued: generate-workflow (${args.kind}) for ${args.recordingId}`,
-    );
-    return {
-      queued: true,
-      recordingId: args.recordingId,
-      kind: args.kind,
-      stateKey,
-      includeFullVideoInAi,
-    };
+      console.log(
+        `Delegation queued: generate-workflow (${args.kind}) for ${args.recordingId}`,
+      );
+      return {
+        queued: true,
+        recordingId: args.recordingId,
+        kind: args.kind,
+        stateKey,
+        includeFullVideoInAi,
+      };
+    } finally {
+      workflowGenerationLocks.delete(stateKey);
+    }
   },
 });

package/corpus/templates/clips/actions/get-recording-player-data.ts

@@ -20,12 +20,20 @@
 import { defineAction, embedApp } from "@agent-native/core";
 import { readAppState } from "@agent-native/core/application-state";
 import { buildDeepLink } from "@agent-native/core/server";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
 import { resolveAccess, ForbiddenError } from "@agent-native/core/sharing";
-import { asc, eq } from "drizzle-orm";
+import { and, asc, eq, or, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { resolvePlayerVideoUrl } from "../server/lib/player-video-url.js";
+import {
+  canOpenDirectRecordingPage,
+  isRecordingExpired,
+} from "../server/lib/recording-page-access.js";
 import { parseSpaceIds } from "../server/lib/recordings.js";
 import { parseBrowserDiagnosticsRow } from "../shared/browser-diagnostics.js";
 import {
@@ -106,6 +114,61 @@ export default defineAction({
     const db = getDb();
     const rec: any = access.resource;
 
+    if (isRecordingExpired(rec.expiresAt)) {
+      throw new ForbiddenError("Recording has expired");
+    }
+
+    let hasExplicitShare = access.role === "owner";
+    if (rec.visibility === "public" && access.role !== "owner") {
+      const userEmail = getRequestUserEmail()?.trim().toLowerCase();
+      const orgId = getRequestOrgId();
+      const principals = [];
+      if (userEmail) {
+        principals.push(
+          and(
+            eq(schema.recordingShares.principalType, "user"),
+            sql`lower(${schema.recordingShares.principalId}) = ${userEmail}`,
+          ),
+        );
+      }
+      if (orgId) {
+        principals.push(
+          and(
+            eq(schema.recordingShares.principalType, "org"),
+            eq(schema.recordingShares.principalId, orgId),
+          ),
+        );
+      }
+      if (principals.length > 0) {
+        const [share] = await db
+          .select({ id: schema.recordingShares.id })
+          .from(schema.recordingShares)
+          .where(
+            and(
+              eq(schema.recordingShares.resourceId, args.recordingId),
+              or(...principals),
+            ),
+          )
+          .limit(1);
+        hasExplicitShare = Boolean(share);
+      } else {
+        hasExplicitShare = false;
+      }
+    }
+
+    if (
+      !canOpenDirectRecordingPage({
+        role: access.role,
+        visibility: rec.visibility,
+        hasPassword: Boolean(rec.password),
+        hasExplicitShare,
+      })
+    ) {
+      throw new ForbiddenError(
+        "Open this recording from its share link instead of the direct recording URL",
+      );
+    }
+
     const [transcript] = await db
       .select()
       .from(schema.recordingTranscripts)

package/corpus/templates/clips/actions/regenerate-summary.ts

@@ -22,6 +22,12 @@ export default defineAction({
     "Ask the agent to regenerate this recording's description/summary based on its transcript (and the full video when Include full video is enabled).",
   schema: z.object({
     recordingId: z.string().describe("Recording ID"),
+    openInChat: z
+      .boolean()
+      .optional()
+      .describe(
+        "When true, focus the queued generation request in the agent chat instead of keeping it hidden.",
+      ),
   }),
   run: async (args) => {
     await assertAccess("recording", args.recordingId, "editor");
@@ -74,6 +80,7 @@ export default defineAction({
       transcriptStatus: transcript?.status ?? "pending",
       transcriptText: transcript?.fullText ?? "",
       includeFullVideoInAi,
+      openInChat: args.openInChat === true,
       message: withFullVideoAiInstructions(
         baseMessage,
         args.recordingId,

package/corpus/templates/clips/actions/regenerate-title.ts

@@ -59,7 +59,9 @@ function buildTitleContext({
 }): string | undefined {
   const parts: string[] = [];
   if (currentTitle && !isDefaultTitle(currentTitle)) {
-    parts.push(`Current title: ${currentTitle}`);
+    parts.push(
+      `Current title: ${currentTitle}\nWhen regenerating, do not return this title verbatim; choose a more specific alternative when the transcript supports one.`,
+    );
   }
   if (agentsContext) parts.push(agentsContext);
   return parts.length > 0 ? parts.join("\n\n") : undefined;
@@ -237,9 +239,14 @@ export default defineAction({
 
         if (!fresh) throw new Error(`Recording not found: ${args.recordingId}`);
 
+        const titleMatchesCurrent =
+          fresh.title?.trim().toLocaleLowerCase() ===
+          generatedTitle.trim().toLocaleLowerCase();
+
         if (
-          isAutoTitleReplaceable(fresh.title, fresh.titleSource) ||
-          fresh.title === rec.title
+          !titleMatchesCurrent &&
+          (isAutoTitleReplaceable(fresh.title, fresh.titleSource) ||
+            fresh.title === rec.title)
         ) {
           await db
             .update(schema.recordings)
@@ -272,12 +279,18 @@ export default defineAction({
           };
         }
 
-        return {
-          updated: false,
-          skipped: true,
-          reason: "Recording title changed before generation completed",
-          recordingId: args.recordingId,
-        };
+        if (!titleMatchesCurrent) {
+          return {
+            updated: false,
+            skipped: true,
+            reason: "Recording title changed before generation completed",
+            recordingId: args.recordingId,
+          };
+        }
+
+        console.warn(
+          `[clips] AI title regeneration returned the existing title for ${args.recordingId}; queueing a refinement instead`,
+        );
       }
     } catch (err) {
       builderCreditsPaused = isBuilderCreditsExhaustedMessage(
@@ -302,9 +315,14 @@ export default defineAction({
 
       if (!fresh) throw new Error(`Recording not found: ${args.recordingId}`);
 
+      const titleMatchesCurrent =
+        fresh.title?.trim().toLocaleLowerCase() ===
+        fallbackTitle.trim().toLocaleLowerCase();
+
       if (
-        isAutoTitleReplaceable(fresh.title, fresh.titleSource) ||
-        fresh.title === rec.title
+        !titleMatchesCurrent &&
+        (isAutoTitleReplaceable(fresh.title, fresh.titleSource) ||
+          fresh.title === rec.title)
       ) {
         await db
           .update(schema.recordings)

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

@@ -63,6 +63,7 @@ import {
   parseEdits,
   getExcludedRanges,
   formatMs,
+  skipExcludedRange,
   type EditsJson,
 } from "@/lib/timestamp-mapping";
 import { cn } from "@/lib/utils";
@@ -435,10 +436,15 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
   useEffect(() => {
     const v = videoRef.current;
     if (!v) return;
-    const onTime = () => setPlayheadMs(v.currentTime * 1000);
+    const onTime = () => {
+      const rawMs = v.currentTime * 1000;
+      const visibleMs = skipExcludedRange(rawMs, excludedRanges, durationMs);
+      if (visibleMs !== rawMs) v.currentTime = visibleMs / 1000;
+      setPlayheadMs(visibleMs);
+    };
     v.addEventListener("timeupdate", onTime);
     return () => v.removeEventListener("timeupdate", onTime);
-  }, [videoUrl]);
+  }, [durationMs, excludedRanges, videoUrl]);
 
   // Expose the in-editor state so the agent can read "the user is editing and scrubbed to X".
   useEffect(() => {
@@ -510,11 +516,15 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
     [recordingId, trim],
   );
 
-  const seek = useCallback((ms: number) => {
-    const v = videoRef.current;
-    if (v) v.currentTime = ms / 1000;
-    setPlayheadMs(ms);
-  }, []);
+  const seek = useCallback(
+    (ms: number) => {
+      const visibleMs = skipExcludedRange(ms, excludedRanges, durationMs);
+      const v = videoRef.current;
+      if (v) v.currentTime = visibleMs / 1000;
+      setPlayheadMs(visibleMs);
+    },
+    [durationMs, excludedRanges],
+  );
 
   // --- keyboard shortcuts -------------------------------------------------
   useEffect(() => {
@@ -585,8 +595,8 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
 
   // Default selection window so the TrimHandles have something to render.
   const effectiveSelection = selectionRange ?? {
-    startMs: Math.max(0, playheadMs - 1000),
-    endMs: Math.min(durationMs || 1_000, playheadMs + 1000),
+    startMs: 0,
+    endMs: durationMs || 1_000,
   };
 
   if (playerDataQuery.isLoading) {
@@ -684,7 +694,8 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
                 playheadMs={playheadMs}
                 durationMs={durationMs}
                 excludedRanges={excludedRanges}
-                selectionRange={selectionRange}
+                selectionRange={effectiveSelection}
+                splitPoints={splitPoints}
                 activityRanges={transcriptSegments}
                 onSeek={seek}
                 scrollLeft={scrollLeft}
@@ -707,6 +718,7 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
                     value={effectiveSelection}
                     onChange={setSelectionRange}
                     durationMs={durationMs}
+                    splitPoints={splitPoints}
                   />
                 </div>
               </div>
@@ -727,7 +739,6 @@ export function EditorLayout({ recordingId, className }: EditorLayoutProps) {
                   durationMs={durationMs}
                   playheadMs={playheadMs}
                   chapters={chapters}
-                  excludedRanges={excludedRanges}
                   splitPoints={splitPoints}
                   onSeek={seek}
                   onClickChapter={(c) => seek(c.startMs)}