@agent-native/core 0.134.0 → 0.135.0

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

@@ -193,6 +193,12 @@ const migrations = runMigrations(
       description TEXT NOT NULL DEFAULT '',
       thumbnail_url TEXT,
       animated_thumbnail_url TEXT,
+      filmstrip_url TEXT,
+      filmstrip_frame_count INTEGER NOT NULL DEFAULT 0,
+      filmstrip_columns INTEGER NOT NULL DEFAULT 0,
+      filmstrip_rows INTEGER NOT NULL DEFAULT 0,
+      filmstrip_frame_width INTEGER NOT NULL DEFAULT 0,
+      filmstrip_frame_height INTEGER NOT NULL DEFAULT 0,
       duration_ms INTEGER NOT NULL DEFAULT 0,
       video_url TEXT,
       video_format TEXT NOT NULL DEFAULT 'webm',
@@ -899,6 +905,16 @@ const migrations = runMigrations(
         `UPDATE recordings SET upload_lease_expires_at = '${uploadLeaseExpiry()}' WHERE upload_lease_expires_at IS NULL AND status IN ('uploading', 'processing')`,
       ].join("; "),
     },
+    {
+      version: 54,
+      name: "recording-upload-attempt-fence",
+      sql: `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS upload_attempt_id TEXT`,
+    },
+    {
+      version: 55,
+      name: "recording-upload-generation-fence",
+      sql: `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS upload_generation_id TEXT`,
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/_agent-native-background/post-finalize-worker.post.ts

@@ -66,6 +66,7 @@ export default defineEventHandler(async (event: H3Event) => {
       ownerEmail: schema.recordings.ownerEmail,
       orgId: schema.recordings.orgId,
       status: schema.recordings.status,
+      uploadGenerationId: schema.recordings.uploadGenerationId,
     })
     .from(schema.recordings)
     .where(eq(schema.recordings.id, recordingId))
@@ -120,6 +121,9 @@ export default defineEventHandler(async (event: H3Event) => {
         const result = await finalizeRecording.run({
           id: recordingId,
           mediaVerificationRetryAttempt: retryAttempt ?? 1,
+          ...(recording.uploadGenerationId
+            ? { uploadGenerationId: recording.uploadGenerationId }
+            : {}),
         });
         return { ok: true, kind, result };
       }

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -6,14 +6,13 @@
  */
 
 import {
-  deleteAppState,
+  compareAndSetManyAppState,
   readAppState,
   writeAppState,
-  deleteAppStateByPrefix,
 } from "@agent-native/core/application-state";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { isStoredButUnservableFinalizeError } from "@shared/finalize-recovery.js";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import {
   defineEventHandler,
   getRouterParam,
@@ -24,6 +23,7 @@ import {
 
 import { getDb, schema } from "../../../../db/index.js";
 import { mediaVerificationStateKey } from "../../../../lib/media-verification-state.js";
+import { deleteRecordingChunks } from "../../../../lib/recording-upload-state.js";
 import {
   getEventOwnerContext,
   ownerEmailMatches,
@@ -44,11 +44,25 @@ export default defineEventHandler(async (event: H3Event) => {
   const { userEmail: ownerEmail, orgId } = await getEventOwnerContext(event);
   const body = (await readBody(event).catch(() => null)) as {
     reason?: unknown;
+    attemptId?: unknown;
+    uploadGenerationId?: unknown;
   } | null;
   const failureReason =
     typeof body?.reason === "string" && body.reason.trim()
       ? body.reason.trim().slice(0, 1000)
       : "Upload aborted by user";
+  const requestedAttemptId =
+    typeof body?.attemptId === "string" &&
+    body.attemptId.length > 0 &&
+    body.attemptId.length <= 128
+      ? body.attemptId
+      : null;
+  const requestedGenerationId =
+    typeof body?.uploadGenerationId === "string" &&
+    body.uploadGenerationId.length > 0 &&
+    body.uploadGenerationId.length <= 128
+      ? body.uploadGenerationId
+      : null;
 
   return runWithRequestContext({ userEmail: ownerEmail, orgId }, async () => {
     const db = getDb();
@@ -59,6 +73,8 @@ export default defineEventHandler(async (event: H3Event) => {
         status: schema.recordings.status,
         videoUrl: schema.recordings.videoUrl,
         failureReason: schema.recordings.failureReason,
+        uploadAttemptId: schema.recordings.uploadAttemptId,
+        uploadGenerationId: schema.recordings.uploadGenerationId,
       })
       .from(schema.recordings)
       .where(
@@ -73,17 +89,43 @@ export default defineEventHandler(async (event: H3Event) => {
       return { error: "Recording not found" };
     }
 
+    const existingAttemptId = existing.uploadAttemptId ?? null;
+    const existingGenerationId = existing.uploadGenerationId ?? null;
+    if (
+      requestedAttemptId !== existingAttemptId ||
+      requestedGenerationId !== existingGenerationId
+    ) {
+      setResponseStatus(event, 409);
+      return {
+        error: "A newer upload retry is already active.",
+        staleAttempt: true,
+      };
+    }
+
     if (existing.status === "ready" && existing.videoUrl) {
       return { ok: true, recordingId, alreadyReady: true, chunksCleared: 0 };
     }
 
-    const existingUploadStateRaw = await readAppState(
-      `recording-upload-${recordingId}`,
-    ).catch(() => null);
+    const uploadStateKey = `recording-upload-${recordingId}`;
+    const verificationStateKey = mediaVerificationStateKey(recordingId);
+    const [existingUploadStateRaw, existingVerificationStateRaw] =
+      await Promise.all([
+        readAppState(uploadStateKey),
+        readAppState(verificationStateKey),
+      ]);
     const existingUploadState =
       existingUploadStateRaw && typeof existingUploadStateRaw === "object"
         ? (existingUploadStateRaw as Record<string, unknown>)
         : {};
+    const existingUploadStateSnapshot =
+      existingUploadStateRaw && typeof existingUploadStateRaw === "object"
+        ? (existingUploadStateRaw as Record<string, unknown>)
+        : null;
+    const existingVerificationStateSnapshot =
+      existingVerificationStateRaw &&
+      typeof existingVerificationStateRaw === "object"
+        ? (existingVerificationStateRaw as Record<string, unknown>)
+        : null;
     if (
       existing.status === "processing" &&
       existingUploadState.pendingMediaVerification === true
@@ -99,46 +141,87 @@ export default defineEventHandler(async (event: H3Event) => {
     const preserveRecoveryState =
       isStoredButUnservableFinalizeError(failureReason) ||
       isStoredButUnservableFinalizeError(existing.failureReason);
-    const resumableSession = preserveRecoveryState
+    let resumableSession = preserveRecoveryState
       ? null
-      : await getResumableSession(recordingId).catch(() => null);
-
-    // Already a terminal failure (e.g. a duplicate/retried abort call, or
-    // finalize's own failChunkAssembly already flipped it) — no-op unless a
-    // prior provider cleanup failure intentionally retained a resumable
-    // session for this retry.
-    if (
-      existing.status === "failed" &&
-      !preserveRecoveryState &&
-      !resumableSession
-    ) {
-      return { ok: true, recordingId, alreadyFailed: true, chunksCleared: 0 };
-    }
+      : await getResumableSession(recordingId, existingGenerationId);
 
     const now = new Date().toISOString();
-    await db
+    const aborted = await db
       .update(schema.recordings)
       .set({
         status: "failed",
         failureReason,
         updatedAt: now,
       })
-      .where(eq(schema.recordings.id, recordingId));
-
-    await writeAppState(`recording-upload-${recordingId}`, {
-      ...existingUploadState,
-      recordingId,
-      status: "failed",
-      failureReason,
-      updatedAt: now,
-    });
-    await deleteAppState(mediaVerificationStateKey(recordingId)).catch(
-      () => {},
-    );
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          eq(schema.recordings.status, existing.status),
+          existingAttemptId === null
+            ? isNull(schema.recordings.uploadAttemptId)
+            : eq(schema.recordings.uploadAttemptId, existingAttemptId),
+          existingGenerationId === null
+            ? isNull(schema.recordings.uploadGenerationId)
+            : eq(schema.recordings.uploadGenerationId, existingGenerationId),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+
+    if (aborted.length !== 1) {
+      setResponseStatus(event, 409);
+      return {
+        error: "A newer upload retry is already active.",
+        staleAttempt: true,
+      };
+    }
+
+    const auxiliaryStateUpdated = await compareAndSetManyAppState([
+      {
+        key: uploadStateKey,
+        expectedValue: existingUploadStateSnapshot,
+        nextValue: {
+          ...existingUploadState,
+          recordingId,
+          status: "failed",
+          failureReason,
+          updatedAt: now,
+        },
+      },
+      ...(existingVerificationStateSnapshot
+        ? [
+            {
+              key: verificationStateKey,
+              expectedValue: existingVerificationStateSnapshot,
+              nextValue: null,
+            },
+          ]
+        : []),
+    ]);
+    if (!auxiliaryStateUpdated) {
+      console.info(
+        `[abort] upload state changed after abort claim; preserving replacement state for ${recordingId}`,
+      );
+    }
+
+    // Reset may have started this exact generation's provider session after
+    // our preflight read but before the abort claim. Re-read after the row CAS
+    // so either abort observes the late handle or reset observes the lost row
+    // claim and compensates it.
+    if (!preserveRecoveryState) {
+      resumableSession = await getResumableSession(
+        recordingId,
+        existingGenerationId,
+      );
+    }
 
     const cleared = preserveRecoveryState
       ? 0
-      : await deleteAppStateByPrefix(`recording-chunks-${recordingId}-`);
+      : await deleteRecordingChunks(
+          ownerEmail,
+          recordingId,
+          existingGenerationId,
+        );
     if (!preserveRecoveryState) {
       if (resumableSession) {
         const provider = await resolveResumableUploadProvider(
@@ -166,10 +249,14 @@ export default defineEventHandler(async (event: H3Event) => {
         // retry can still address the multipart upload. Deleting it here would
         // permanently orphan the provider-side session.
         if (providerCleanupSucceeded) {
-          await deleteResumableSession(recordingId).catch(() => {});
+          await deleteResumableSession(recordingId, existingGenerationId).catch(
+            () => {},
+          );
         }
       } else {
-        await deleteResumableSession(recordingId).catch(() => {});
+        await deleteResumableSession(recordingId, existingGenerationId).catch(
+          () => {},
+        );
       }
     }
     await writeAppState("refresh-signal", { ts: Date.now() });

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -17,6 +17,7 @@ import {
   readAppState,
   writeAppState,
 } from "@agent-native/core/application-state";
+import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { track } from "@agent-native/core/tracking";
 import { normalizeChunkUploadNumber } from "@shared/recording-core.js";
@@ -34,6 +35,7 @@ import {
 } from "h3";
 
 import finalizeRecording from "../../../../../actions/finalize-recording.js";
+import { UPLOAD_RETRY_RESUME_FLAG } from "../../../../../shared/feature-flags.js";
 import { getDb, schema } from "../../../../db/index.js";
 import { debugLog } from "../../../../lib/debug.js";
 import {
@@ -45,6 +47,7 @@ import {
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
 import {
+  deleteResumableSession,
   getResumableSession,
   setResumableSession,
   type StoredResumableSession,
@@ -166,6 +169,26 @@ export default defineEventHandler(async (event: H3Event) => {
   }
 
   const query = getQuery(event);
+  const attemptIdValue = Array.isArray(query.attemptId)
+    ? query.attemptId[0]
+    : query.attemptId;
+  const attemptId =
+    typeof attemptIdValue === "string" &&
+    attemptIdValue.length > 0 &&
+    attemptIdValue.length <= 128 &&
+    !/[\r\n]/.test(attemptIdValue)
+      ? attemptIdValue
+      : null;
+  const uploadGenerationIdValue = Array.isArray(query.uploadGenerationId)
+    ? query.uploadGenerationId[0]
+    : query.uploadGenerationId;
+  const uploadGenerationId =
+    typeof uploadGenerationIdValue === "string" &&
+    uploadGenerationIdValue.length > 0 &&
+    uploadGenerationIdValue.length <= 128 &&
+    !/[\r\n]/.test(uploadGenerationIdValue)
+      ? uploadGenerationIdValue
+      : null;
   const index = Number(query.index ?? 0);
   const total = Number(query.total ?? 0);
   const isFinal = query.isFinal === "1" || query.isFinal === "true";
@@ -188,7 +211,12 @@ export default defineEventHandler(async (event: H3Event) => {
     mimeType,
   });
 
-  if (!Number.isFinite(index) || !Number.isInteger(index) || index < 0) {
+  if (
+    !Number.isFinite(index) ||
+    !Number.isInteger(index) ||
+    index < 0 ||
+    index > 999_999
+  ) {
     throw createError({ statusCode: 400, message: "Invalid chunk index" });
   }
 
@@ -210,6 +238,23 @@ export default defineEventHandler(async (event: H3Event) => {
   }
   debugLog("[chunk] resolved owner:", ownerEmail);
 
+  if (
+    attemptId !== null &&
+    !(await isFeatureFlagEnabled(UPLOAD_RETRY_RESUME_FLAG, {
+      userEmail: ownerEmail,
+      userKey: ownerEmail,
+      orgId,
+    }))
+  ) {
+    setResponseStatus(event, 409);
+    return {
+      ok: false,
+      error: "Resumable upload retry is disabled.",
+      restartRequired: true,
+      recoveryEnabled: false,
+    };
+  }
+
   return runWithRequestContext({ userEmail: ownerEmail, orgId }, async () => {
     const db = getDb();
 
@@ -219,6 +264,7 @@ export default defineEventHandler(async (event: H3Event) => {
       .select({
         id: schema.recordings.id,
         status: schema.recordings.status,
+        uploadGenerationId: schema.recordings.uploadGenerationId,
       })
       .from(schema.recordings)
       .where(
@@ -252,13 +298,31 @@ export default defineEventHandler(async (event: H3Event) => {
     // The first renewal admits the request. Later renewals immediately before
     // every durable write/finalization boundary close the body-read/provider
     // gap where /abort can otherwise commit while this request is in flight.
+    if ((existing.uploadGenerationId ?? null) !== uploadGenerationId) {
+      setResponseStatus(event, 409);
+      return {
+        ok: false,
+        error: "A newer upload generation is already active.",
+        staleAttempt: true,
+      };
+    }
     const lease = await renewUploadLease(recordingId, {
+      attemptId,
+      generationId: uploadGenerationId,
       uploadProgress:
         total > 0
           ? Math.min(100, Math.round(((index + 1) / total) * 100))
           : undefined,
     });
     if (!lease.held) {
+      if (lease.staleAttempt) {
+        setResponseStatus(event, 409);
+        return {
+          ok: false,
+          error: "A newer upload retry is already active.",
+          staleAttempt: true,
+        };
+      }
       if (lease.status === "ready") {
         const readyState = await readAppState(
           `recording-upload-${recordingId}`,
@@ -273,7 +337,11 @@ export default defineEventHandler(async (event: H3Event) => {
           sourceSizeBytes: stateNumber(readyState, "sourceSizeBytes"),
         };
       }
-      await deleteRecordingChunks(ownerEmail, recordingId).catch((err) => {
+      await deleteRecordingChunks(
+        ownerEmail,
+        recordingId,
+        uploadGenerationId,
+      ).catch((err) => {
         console.warn("[chunk] failed upload chunk cleanup failed:", {
           recordingId,
           err: err instanceof Error ? err.message : String(err),
@@ -285,9 +353,16 @@ export default defineEventHandler(async (event: H3Event) => {
     }
 
     const rejectIfLeaseLost = async () => {
-      const current = await renewUploadLease(recordingId);
+      const current = await renewUploadLease(recordingId, {
+        attemptId,
+        generationId: uploadGenerationId,
+      });
       if (current.held) return null;
-      await deleteRecordingChunks(ownerEmail, recordingId).catch((err) => {
+      await deleteRecordingChunks(
+        ownerEmail,
+        recordingId,
+        uploadGenerationId,
+      ).catch((err) => {
         console.warn("[chunk] failed upload chunk cleanup failed:", {
           recordingId,
           err: err instanceof Error ? err.message : String(err),
@@ -308,7 +383,10 @@ export default defineEventHandler(async (event: H3Event) => {
     }
 
     // Resumable streaming path — forward chunks directly to the provider.
-    const resumableSession = await getResumableSession(recordingId);
+    const resumableSession = await getResumableSession(
+      recordingId,
+      uploadGenerationId,
+    );
     if (resumableSession && isStreamingUploadDisabled()) {
       console.warn(
         `[chunk] streaming uploads are disabled, but preserving existing resumable session for in-flight recording: ${recordingId}`,
@@ -324,6 +402,8 @@ export default defineEventHandler(async (event: H3Event) => {
         mimeType,
         query,
         ownerEmail,
+        attemptId,
+        uploadGenerationId,
       );
     }
 
@@ -418,7 +498,11 @@ export default defineEventHandler(async (event: H3Event) => {
         maxBytes: MAX_RECORDING_UPLOAD_BYTES,
         updatedAt: now,
       });
-      await deleteRecordingChunks(ownerEmail, recordingId).catch((err) => {
+      await deleteRecordingChunks(
+        ownerEmail,
+        recordingId,
+        uploadGenerationId,
+      ).catch((err) => {
         console.warn("[chunk] oversized upload chunk cleanup failed:", {
           recordingId,
           err: err instanceof Error ? err.message : String(err),
@@ -439,12 +523,13 @@ export default defineEventHandler(async (event: H3Event) => {
       // Pad index to 6 digits so string-sort order matches numeric order if the
       // finalize path ever sorts lexically. (finalize also parses back to a number.)
       const paddedIndex = String(index).padStart(6, "0");
-      const chunkKey = `recording-chunks-${recordingId}-${paddedIndex}`;
+      const chunkKey = `recording-chunks-${recordingId}${uploadGenerationId ? `-${uploadGenerationId}` : ""}-${paddedIndex}`;
       const previousChunk = await readAppState(chunkKey);
       const previousBytes = stateNumber(previousChunk, "bytes") ?? 0;
       const persistedBytesBefore = await sumRecordingChunkBytes(
         ownerEmail,
         recordingId,
+        uploadGenerationId,
       );
       const nextBytes =
         Math.max(0, persistedBytesBefore - previousBytes) + bytes.byteLength;
@@ -463,7 +548,11 @@ export default defineEventHandler(async (event: H3Event) => {
         data: toBase64(bytes),
         createdAt: new Date().toISOString(),
       });
-      bytesReceived = await sumRecordingChunkBytes(ownerEmail, recordingId);
+      bytesReceived = await sumRecordingChunkBytes(
+        ownerEmail,
+        recordingId,
+        uploadGenerationId,
+      );
       if (bytesReceived > MAX_RECORDING_UPLOAD_BYTES) {
         return failRecordingTooLarge(bytesReceived);
       }
@@ -487,6 +576,7 @@ export default defineEventHandler(async (event: H3Event) => {
       if (leaseFailure) return leaseFailure;
       await writeAppState(`recording-upload-${recordingId}`, {
         recordingId,
+        uploadGenerationId,
         status: isFinal ? "processing" : "uploading",
         progress,
         chunksReceived,
@@ -508,6 +598,7 @@ export default defineEventHandler(async (event: H3Event) => {
       if (leaseFailure) return leaseFailure;
       await writeAppState(`recording-upload-${recordingId}`, {
         recordingId,
+        uploadGenerationId,
         status: isFinal ? "processing" : "uploading",
         chunksReceived: Math.max(
           stateNumber(uploadState, "chunksReceived") ?? 0,
@@ -532,7 +623,11 @@ export default defineEventHandler(async (event: H3Event) => {
     if (isFinal) {
       const leaseFailure = await rejectIfLeaseLost();
       if (leaseFailure) return leaseFailure;
-      bytesReceived = await sumRecordingChunkBytes(ownerEmail, recordingId);
+      bytesReceived = await sumRecordingChunkBytes(
+        ownerEmail,
+        recordingId,
+        uploadGenerationId,
+      );
       if (bytesReceived > MAX_RECORDING_UPLOAD_BYTES) {
         return failRecordingTooLarge(bytesReceived);
       }
@@ -541,7 +636,7 @@ export default defineEventHandler(async (event: H3Event) => {
       debugLog("[chunk] isFinal — invoking finalize", { recordingId });
       try {
         const result = await finalizeRecording.run(
-          buildFinalizeArgs(recordingId, mimeType, query),
+          buildFinalizeArgs(recordingId, mimeType, query, uploadGenerationId),
         );
         debugLog("[chunk] finalize ok", {
           recordingId,
@@ -713,6 +808,7 @@ function buildFinalizeArgs(
   recordingId: string,
   mimeType: string,
   query: Record<string, unknown>,
+  uploadGenerationId: string | null,
 ) {
   const queryBoolean = (value: unknown): boolean | undefined => {
     if (value === undefined) return undefined;
@@ -729,6 +825,7 @@ function buildFinalizeArgs(
     hasCamera: queryBoolean(query.hasCamera),
     locallyTranscoded: queryBoolean(query.locallyTranscoded),
     mimeType,
+    ...(uploadGenerationId ? { uploadGenerationId } : {}),
   };
 }
 
@@ -743,6 +840,8 @@ async function handleResumableChunk(
   mimeType: string,
   query: Record<string, unknown>,
   ownerEmail: string,
+  attemptId: string | null,
+  uploadGenerationId: string | null,
 ) {
   const uploadProvider = await resolveResumableUploadProvider(
     session.providerId,
@@ -771,7 +870,10 @@ async function handleResumableChunk(
         error: "Cannot finalize an empty resumable upload",
       };
     }
-    const lease = await renewUploadLease(recordingId);
+    const lease = await renewUploadLease(recordingId, {
+      attemptId,
+      generationId: uploadGenerationId,
+    });
     if (!lease.held) {
       setResponseStatus(event, 409);
       return {
@@ -798,7 +900,10 @@ async function handleResumableChunk(
       };
     }
     if (closeRes.updatedMeta) {
-      const postCloseLease = await renewUploadLease(recordingId);
+      const postCloseLease = await renewUploadLease(recordingId, {
+        attemptId,
+        generationId: uploadGenerationId,
+      });
       if (!postCloseLease.held) {
         setResponseStatus(event, 409);
         return {
@@ -808,10 +913,14 @@ async function handleResumableChunk(
             "Recording upload has already failed.",
         };
       }
-      await setResumableSession(recordingId, {
-        ...session,
-        meta: { ...session.meta, ...closeRes.updatedMeta },
-      });
+      await setResumableSession(
+        recordingId,
+        {
+          ...session,
+          meta: { ...session.meta, ...closeRes.updatedMeta },
+        },
+        uploadGenerationId,
+      );
     }
   } else {
     // Idempotent replay guard: a client retry (after a lost response) can
@@ -835,7 +944,10 @@ async function handleResumableChunk(
         };
       }
     } else {
-      const lease = await renewUploadLease(recordingId);
+      const lease = await renewUploadLease(recordingId, {
+        attemptId,
+        generationId: uploadGenerationId,
+      });
       if (!lease.held) {
         setResponseStatus(event, 409);
         return {
@@ -866,14 +978,25 @@ async function handleResumableChunk(
         ? putResult.ok && putResult.status !== 308
         : putResult.ok;
       if (!resultOk) {
-        setResponseStatus(event, 502);
+        const restartRequired =
+          putResult.status === 404 || putResult.status === 410;
+        if (restartRequired) {
+          await deleteResumableSession(recordingId, uploadGenerationId).catch(
+            () => {},
+          );
+        }
+        setResponseStatus(event, restartRequired ? 409 : 502);
         return {
           ok: false,
           error: `Chunk upload failed (${putResult.status})`,
+          ...(restartRequired ? { restartRequired: true } : {}),
         };
       }
 
-      const postUploadLease = await renewUploadLease(recordingId);
+      const postUploadLease = await renewUploadLease(recordingId, {
+        attemptId,
+        generationId: uploadGenerationId,
+      });
       if (!postUploadLease.held) {
         setResponseStatus(event, 409);
         return {
@@ -883,14 +1006,18 @@ async function handleResumableChunk(
             "Recording upload has already failed.",
         };
       }
-      await setResumableSession(recordingId, {
-        ...session,
-        ...(putResult.updatedMeta
-          ? { meta: { ...session.meta, ...putResult.updatedMeta } }
-          : {}),
-        bytesUploaded: start + bytes.byteLength,
-        lastCommittedIndex: index,
-      });
+      await setResumableSession(
+        recordingId,
+        {
+          ...session,
+          ...(putResult.updatedMeta
+            ? { meta: { ...session.meta, ...putResult.updatedMeta } }
+            : {}),
+          bytesUploaded: start + bytes.byteLength,
+          lastCommittedIndex: index,
+        },
+        uploadGenerationId,
+      );
       finalizedSourceSizeBytes = start + bytes.byteLength;
 
       if (!isFinal) {
@@ -901,7 +1028,10 @@ async function handleResumableChunk(
 
   // isFinal — delegate to finalize-recording, which reads the resumable
   // session and calls provider.resumable.completeSession.
-  const finalLease = await renewUploadLease(recordingId);
+  const finalLease = await renewUploadLease(recordingId, {
+    attemptId,
+    generationId: uploadGenerationId,
+  });
   if (!finalLease.held) {
     setResponseStatus(event, 409);
     return {
@@ -911,7 +1041,7 @@ async function handleResumableChunk(
   }
   try {
     const result = await finalizeRecording.run(
-      buildFinalizeArgs(recordingId, mimeType, query),
+      buildFinalizeArgs(recordingId, mimeType, query, uploadGenerationId),
     );
     if ((result as any)?.status === "failed") {
       setResponseStatus(event, 409);