diff --git a/Plugins/SecondDimensionWatcherReDive.Chat/Tools/ManageDownloadsTool.cs b/Plugins/SecondDimensionWatcherReDive.Chat/Tools/ManageDownloadsTool.cs
index 831ec4b..9e22f06 100644
--- a/Plugins/SecondDimensionWatcherReDive.Chat/Tools/ManageDownloadsTool.cs
+++ b/Plugins/SecondDimensionWatcherReDive.Chat/Tools/ManageDownloadsTool.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using SecondDimensionWatcherReDive.AI.Models;
 using SecondDimensionWatcherReDive.Framework.AI;
 using SecondDimensionWatcherReDive.Framework.Attributes;
@@ -14,6 +15,12 @@ internal sealed partial class ManageDownloadsTool(
     IFileMappingRepository fileMappingRepository,
     IFileDownloadClientProvider fileDownloadClientProvider) : ITool
 {
+    private static readonly TimeSpan DownloadSubmissionLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadSubmissionRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadCancellationLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadCancellationRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadLeaseSafetyMargin = TimeSpan.FromSeconds(1);
+
     private async Task<IToolResult> ExecuteCoreAsync(
         ManageDownloadsParams param, CancellationToken cancellationToken)
     {
@@ -45,32 +52,71 @@ private async Task<IToolResult> StartDownloadAsync(
             return new ToolFailureResult("Download already tracked");
 
         var downloadAttemptId = Guid.NewGuid();
+        var submissionLeaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
         var submissionAttempted = false;
         try
         {
-            if (!await animationInfoRepository.TryStartDownloadAsync(
+            var submissionLease = await animationInfoRepository.TryStartDownloadAsync(
                     info.Id,
                     downloadAttemptId,
+                    submissionLeaseId,
+                    DownloadSubmissionLeaseDuration,
                     DateTimeOffset.Now,
                     queuedDisposition: null,
-                    cancellationToken))
+                    cancellationToken);
+            if (submissionLease is null)
                 return new ToolFailureResult("Download already tracked");
 
+            var remainingRemoteBudget = DownloadSubmissionRemoteBudget -
+                                        Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+            if (remainingRemoteBudget <= TimeSpan.Zero)
+            {
+                await CompensateFailedStartAsync(
+                    info,
+                    client,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: false);
+                return new ToolFailureResult("Download submission lease expired");
+            }
+
+            using var submissionCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+                cancellationToken);
+            submissionCancellation.CancelAfter(remainingRemoteBudget);
+            submissionCancellation.Token.ThrowIfCancellationRequested();
             submissionAttempted = true;
             if (!await client.SubmitDownloadTaskAsync(
                     info.Id,
                     info.DownloadUrl,
                     info.CachedDownloadData,
                     info.AdditionalDownloadInfo,
-                    cancellationToken))
+                    submissionCancellation.Token))
             {
                 await CompensateFailedStartAsync(
                     info,
                     client,
                     downloadAttemptId,
+                    submissionLeaseId,
                     remoteMayHaveAccepted: false);
                 return new ToolFailureResult("Download client rejected the task");
             }
+
+            using var markCancellation = CreateDownloadSagaTokenSource();
+            if (!await animationInfoRepository.TryMarkDownloadSubmittedAsync(
+                    info.Id,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    markCancellation.Token))
+            {
+                await CompensateFailedStartAsync(
+                    info,
+                    client,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: true);
+                return new ToolFailureResult("Download state changed during submission");
+            }
         }
         catch
         {
@@ -80,6 +126,7 @@ await CompensateFailedStartAsync(
                     info,
                     client,
                     downloadAttemptId,
+                    submissionLeaseId,
                     submissionAttempted);
             }
             catch
@@ -112,35 +159,57 @@ private async Task<IToolResult> CancelDownloadAsync(
         AnimationInfo info, IFileDownloadClient client, bool removeFile, CancellationToken cancellationToken)
     {
         var cancellationAttemptId = info.DownloadCancellationId ?? Guid.NewGuid();
+        var cancellationLeaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
+        DownloadCancellationLease? cancellationLease;
         cancellationToken.ThrowIfCancellationRequested();
         using (var beginCancellation = CreateDownloadSagaTokenSource())
         {
-            if (!await animationInfoRepository.TryBeginCancelDownloadAsync(
+            cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
                     info.Id,
                     info.DownloadAttemptId,
                     cancellationAttemptId,
-                    beginCancellation.Token))
+                    cancellationLeaseId,
+                    DownloadCancellationLeaseDuration,
+                    removeFile,
+                    requireUnfinished: false,
+                    SubscriptionAutomationDisposition.DownloadCancelled,
+                    beginCancellation.Token);
+            if (cancellationLease is null)
                 return new ToolFailureResult("Download state changed before cancellation");
         }
 
+        var remainingRemoteBudget = DownloadCancellationRemoteBudget -
+                                    Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+        if (remainingRemoteBudget <= TimeSpan.Zero)
+            return new ToolFailureResult("Download cancellation lease expired");
+        using var remoteCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        remoteCancellation.CancelAfter(remainingRemoteBudget);
+        remoteCancellation.Token.ThrowIfCancellationRequested();
         var result = await client.CancelDownloadTaskAsync(
             info.Id,
             info.DownloadUrl,
             info.CachedDownloadData,
             info.AdditionalDownloadInfo,
-            removeFile,
-            cancellationToken);
+            cancellationLease.RemoveFile,
+            remoteCancellation.Token);
 
         if (!result.IsSuccess)
         {
             return new ToolSuccessResult<bool>(false);
         }
 
-        using var finalizeCancellation = CreateDownloadSagaTokenSource();
+        using var finalizeCancellation = CreateLeaseBoundSagaTokenSource(
+            leaseRequestStartedAt,
+            DownloadCancellationLeaseDuration);
+        if (finalizeCancellation is null)
+            return new ToolFailureResult("Download cancellation lease expired");
         var cancelled = await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
             info.Id,
             info.DownloadAttemptId,
             cancellationAttemptId,
+            cancellationLease.Id,
+            SubscriptionAutomationDisposition.DownloadCancelled,
             finalizeCancellation.Token);
         if (!cancelled)
             return new ToolFailureResult("Download state changed during cancellation");
@@ -151,19 +220,35 @@ private async Task CompensateFailedStartAsync(
         AnimationInfo info,
         IFileDownloadClient client,
         Guid downloadAttemptId,
+        Guid submissionLeaseId,
         bool remoteMayHaveAccepted)
     {
         using var cleanup = CreateDownloadSagaTokenSource();
+        var cancellationAttemptId = Guid.NewGuid();
+        var cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+            info.Id,
+            downloadAttemptId,
+            cancellationAttemptId,
+            submissionLeaseId,
+            DownloadCancellationLeaseDuration,
+            removeFile: false,
+            requireUnfinished: true,
+            terminalDisposition: null,
+            cleanup.Token);
+        if (cancellationLease is null)
+            return;
+
         if (remoteMayHaveAccepted)
         {
             try
             {
+                cleanup.Token.ThrowIfCancellationRequested();
                 var remoteCancellation = await client.CancelDownloadTaskAsync(
                     info.Id,
                     info.DownloadUrl,
                     info.CachedDownloadData,
                     info.AdditionalDownloadInfo,
-                    removeFile: false,
+                    cancellationLease.RemoveFile,
                     cleanup.Token);
                 if (!remoteCancellation.IsSuccess)
                 {
@@ -178,9 +263,12 @@ private async Task CompensateFailedStartAsync(
             }
         }
 
-        await animationInfoRepository.TryCancelDownloadAsync(
+        cleanup.Token.ThrowIfCancellationRequested();
+        await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
             info.Id,
             downloadAttemptId,
+            cancellationAttemptId,
+            cancellationLease.Id,
             terminalDisposition: null,
             cleanup.Token);
     }
@@ -207,6 +295,19 @@ await client.SubmitQueryDownloadProgressAsync(
 
     private static CancellationTokenSource CreateDownloadSagaTokenSource() =>
         new(TimeSpan.FromSeconds(10));
+
+    private static CancellationTokenSource? CreateLeaseBoundSagaTokenSource(
+        long leaseRequestStartedAt,
+        TimeSpan leaseDuration)
+    {
+        var remaining = leaseDuration -
+                        Stopwatch.GetElapsedTime(leaseRequestStartedAt) -
+                        DownloadLeaseSafetyMargin;
+        if (remaining <= TimeSpan.Zero)
+            return null;
+        return new CancellationTokenSource(
+            remaining < TimeSpan.FromSeconds(10) ? remaining : TimeSpan.FromSeconds(10));
+    }
 }
 
 internal enum ManageDownloadsAction
diff --git a/Plugins/SecondDimensionWatcherReDive.Inference.AI/Tools/TmdbTool.cs b/Plugins/SecondDimensionWatcherReDive.Inference.AI/Tools/TmdbTool.cs
index 0d30c24..2054522 100644
--- a/Plugins/SecondDimensionWatcherReDive.Inference.AI/Tools/TmdbTool.cs
+++ b/Plugins/SecondDimensionWatcherReDive.Inference.AI/Tools/TmdbTool.cs
@@ -178,6 +178,33 @@ public async Task<string> GetSeasonEpisodesAsync(int tmdbId, int seasonNumber, C
         }
     }
 
+    public async Task<int?> GetExpectedEpisodeCountAsync(
+        int tmdbId,
+        int seasonNumber,
+        CancellationToken cancellationToken)
+    {
+        var tmdbClient = GetClient();
+        if (tmdbClient is null || seasonNumber <= 0) return null;
+
+        try
+        {
+            var show = await tmdbClient.GetTvShowAsync(tmdbId, cancellationToken: cancellationToken);
+            var count = show?.Seasons?
+                .FirstOrDefault(season => season.SeasonNumber == seasonNumber)
+                ?.EpisodeCount;
+            return count is > 0 ? count : null;
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            LogGetSeasonsFailed(_logger, ex, tmdbId);
+            return null;
+        }
+    }
+
     /// <summary>
     ///     Fetches localized name, original name, and overview for a TV show from TMDB,
     ///     using the server's current culture as the language.
diff --git a/SecondDimensionWatcherReDive.Client/mock-server.mjs b/SecondDimensionWatcherReDive.Client/mock-server.mjs
index 3583b98..888a001 100644
--- a/SecondDimensionWatcherReDive.Client/mock-server.mjs
+++ b/SecondDimensionWatcherReDive.Client/mock-server.mjs
@@ -423,6 +423,7 @@ function initAnimations() {
           }
         : null,
       isAiProcessed: !!entry.animeName,
+      isMediaLibraryImport: i === 2,
     });
   });
 }
@@ -742,6 +743,9 @@ const subscriptionPolicies = new Map([
       maxSizeBytes: 1600 * 1024 * 1024,
       excludedKeywords: ["合集", "NCOP"],
       mode: "ManualConfirm",
+      enableVersionUpgrade: true,
+      minimumUpgradeScore: 80,
+      upgradeRollbackHours: 72,
       createdAt: POLICY_CREATED_AT,
       updatedAt: new Date(Date.now() - 3600_000 * 8).toISOString(),
     },
@@ -758,6 +762,9 @@ const subscriptionPolicies = new Map([
       maxSizeBytes: 1400 * 1024 * 1024,
       excludedKeywords: ["预告"],
       mode: "AutoDownload",
+      enableVersionUpgrade: false,
+      minimumUpgradeScore: 25,
+      upgradeRollbackHours: 72,
       createdAt: POLICY_CREATED_AT,
       updatedAt: new Date(Date.now() - 3600_000 * 3).toISOString(),
     },
@@ -2503,6 +2510,166 @@ async function route(method, pathname, searchParams, req, res) {
 
   // --- Animation Info ---
 
+  if (method === "GET" && pathname === "/api/library/search") {
+    const q = (searchParams.get("q") ?? "").toLocaleLowerCase();
+    const season = searchParams.get("season");
+    const episode = searchParams.get("episode");
+    const source = searchParams.get("source") ?? "Any";
+    const downloadState = searchParams.get("downloadState") ?? "Any";
+    const resolution = searchParams.get("resolution");
+    const codec = searchParams.get("codec");
+    const pathQuery = (searchParams.get("path") ?? "").toLocaleLowerCase();
+    const take = Math.min(
+      100,
+      Math.max(1, Number(searchParams.get("take") ?? 30)),
+    );
+    let offset = 0;
+    try {
+      if (searchParams.get("cursor"))
+        offset =
+          Number(
+            Buffer.from(searchParams.get("cursor"), "base64url").toString(
+              "utf8",
+            ),
+          ) || 0;
+    } catch {}
+
+    const mapped = [...animations.values()]
+      .map((item, index) => {
+        const group = item.group?.name ?? null;
+        const itemResolution = /2160p/i.test(item.title) ? "2160p" : "1080p";
+        const itemCodec = /HEVC/i.test(item.title) ? "HEVC" : "AVC";
+        const name = item.animation?.name ?? item.title;
+        const virtualPaths = item.isDownloadFinished
+          ? [
+              `/${name}/${group ?? "Unknown"}/${name} S${String(item.season ?? 1).padStart(2, "0")}E${String(item.episode ?? 1).padStart(2, "0")}.mkv`,
+            ]
+          : [];
+        return {
+          animationInfoId: item.id,
+          title: item.title,
+          animationName: item.animation?.name ?? null,
+          animationOriginalName: item.animation?.originalName ?? null,
+          tmdbId: item.animation?.tmdbId ?? null,
+          season: item.season,
+          episode: item.episode,
+          subtitleGroup: group,
+          resolution: itemResolution,
+          codec: itemCodec,
+          languages: index % 2 ? ["ja"] : ["zh-CN"],
+          isDownloadTracked: item.isDownloadTracked,
+          isDownloadFinished: item.isDownloadFinished,
+          isMediaLibraryImport: item.isMediaLibraryImport,
+          isWatched: false,
+          playbackPositionSeconds: null,
+          virtualPaths,
+          virtualPathCount: virtualPaths.length,
+          releaseScore: 260 + (index % 5) * 55,
+          scoreReasons: [
+            `resolution:${itemResolution}:+200`,
+            `codec:${itemCodec}:+40`,
+          ],
+          publishedAt: item.publishTime,
+        };
+      })
+      .filter((item) => {
+        const haystack = [
+          item.title,
+          item.animationName,
+          item.animationOriginalName,
+          item.tmdbId,
+          item.subtitleGroup,
+          ...item.virtualPaths,
+        ]
+          .filter(Boolean)
+          .join(" ")
+          .toLocaleLowerCase();
+        if (q && !haystack.includes(q)) return false;
+        if (season && item.season !== Number(season)) return false;
+        if (episode && item.episode !== Number(episode)) return false;
+        if (source === "MediaLibraryImport" && !item.isMediaLibraryImport)
+          return false;
+        if (source === "Torrent" && item.isMediaLibraryImport) return false;
+        if (downloadState === "Downloaded" && !item.isDownloadFinished)
+          return false;
+        if (
+          downloadState === "Downloading" &&
+          (!item.isDownloadTracked || item.isDownloadFinished)
+        )
+          return false;
+        if (downloadState === "NotDownloaded" && item.isDownloadTracked)
+          return false;
+        if (
+          resolution &&
+          item.resolution.toLocaleLowerCase() !== resolution.toLocaleLowerCase()
+        )
+          return false;
+        if (
+          codec &&
+          item.codec.toLocaleLowerCase() !== codec.toLocaleLowerCase()
+        )
+          return false;
+        if (
+          pathQuery &&
+          !item.virtualPaths.some((path) =>
+            path.toLocaleLowerCase().includes(pathQuery),
+          )
+        )
+          return false;
+        return true;
+      });
+    const items = mapped.slice(offset, offset + take);
+    const nextCursor =
+      offset + take < mapped.length
+        ? Buffer.from(String(offset + take)).toString("base64url")
+        : null;
+    return json(res, { items, nextCursor });
+  }
+
+  if (method === "GET" && pathname === "/api/library/integrity") {
+    const values = [...animations.values()];
+    const current = values[0];
+    const candidate = values[21] ?? values[1];
+    return json(res, [
+      {
+        tmdbId: current.animation?.tmdbId ?? "209867",
+        animationName: current.animation?.name ?? "葬送的芙莉莲",
+        season: 1,
+        expectedEpisodeCount: 28,
+        missingEpisodes: [25],
+        duplicateEpisodes: [
+          { episode: 28, releaseIds: [current.id, candidate.id] },
+        ],
+        unidentifiedReleaseCount: 1,
+        upgradeCandidates: [
+          {
+            currentReleaseId: current.id,
+            candidateReleaseId: candidate.id,
+            animationName: current.animation?.name ?? "葬送的芙莉莲",
+            season: 1,
+            episode: 28,
+            currentScore: 300,
+            candidateScore: 480,
+            scoreReasons: ["resolution:2160p:+400", "codec:AV1:+80"],
+            automatic: true,
+          },
+        ],
+      },
+    ]);
+  }
+
+  if (method === "POST" && pathname === "/api/library/upgrades/execute") {
+    const body = await readBody(req);
+    return json(res, {
+      isSuccess: true,
+      outcome: body.dryRun ? "ready" : "download_queued",
+      dryRun: !!body.dryRun,
+      requiresDownload: true,
+      operation: body.dryRun ? null : { id: randomUUID() },
+      validationErrors: [],
+    });
+  }
+
   if (method === "GET" && pathname === "/api/animationinfo") {
     const skip = parseInt(searchParams.get("skip") ?? "0", 10);
     const take = parseInt(searchParams.get("take") ?? "10", 10);
@@ -2956,6 +3123,13 @@ async function route(method, pathname, searchParams, req, res) {
             )
               ? body.mode
               : "ManualConfirm",
+            enableVersionUpgrade: !!body.enableVersionUpgrade,
+            minimumUpgradeScore: Number.isInteger(body.minimumUpgradeScore)
+              ? body.minimumUpgradeScore
+              : 25,
+            upgradeRollbackHours: Number.isInteger(body.upgradeRollbackHours)
+              ? body.upgradeRollbackHours
+              : 72,
             createdAt: existing?.createdAt ?? new Date().toISOString(),
             updatedAt: new Date().toISOString(),
           };
diff --git a/SecondDimensionWatcherReDive.Client/src/Main.tsx b/SecondDimensionWatcherReDive.Client/src/Main.tsx
index accfaf7..b43716c 100644
--- a/SecondDimensionWatcherReDive.Client/src/Main.tsx
+++ b/SecondDimensionWatcherReDive.Client/src/Main.tsx
@@ -17,6 +17,7 @@ import {
   loadMainPage,
   loadMetadataReviewPage,
   loadPlayerPage,
+  loadSearchPage,
   loadSettingsPage,
   loadTasksPage,
   loadTodoPage,
@@ -55,6 +56,9 @@ const MetadataReviewPage = React.lazy(async () => ({
 const PlayerPage = React.lazy(async () => ({
   default: (await loadPlayerPage()).PlayerPage,
 }));
+const SearchPage = React.lazy(async () => ({
+  default: (await loadSearchPage()).SearchPage,
+}));
 const SettingsPage = React.lazy(async () => ({
   default: (await loadSettingsPage()).SettingsPage,
 }));
@@ -120,6 +124,15 @@ const router = createBrowserRouter([
     ),
     errorElement: <ErrorPage />,
   },
+  {
+    path: "/search",
+    element: (
+      <ProtectedRoute>
+        <SearchPage />
+      </ProtectedRoute>
+    ),
+    errorElement: <ErrorPage />,
+  },
   {
     path: "/play/:animationId",
     element: (
diff --git a/SecondDimensionWatcherReDive.Client/src/components/AppHeader.tsx b/SecondDimensionWatcherReDive.Client/src/components/AppHeader.tsx
index 8ee9f6d..5389ff1 100644
--- a/SecondDimensionWatcherReDive.Client/src/components/AppHeader.tsx
+++ b/SecondDimensionWatcherReDive.Client/src/components/AppHeader.tsx
@@ -17,6 +17,7 @@ import {
   List,
   Menu,
   MessageSquare,
+  Search,
   Settings,
   User,
 } from "lucide-react";
@@ -55,6 +56,7 @@ const createNavItems = (
   todoCount?: number,
 ): NavItem[] => [
   { icon: <Home size={16} />, labelKey: "nav.home", path: "/" },
+  { icon: <Search size={16} />, labelKey: "nav.search", path: "/search" },
   {
     icon: <BellRing size={16} />,
     labelKey: "nav.todo",
@@ -267,7 +269,18 @@ export const AppHeader: React.FC = () => {
   const { data: todos } = useTodos({ take: 1 });
   const navigate = useNavigate();
   const items = createNavItems(incidents?.openCount, todos?.unreadCount);
+  const location = useLocation();
+  const [searchQuery, setSearchQuery] = React.useState(
+    location.pathname === "/search"
+      ? (new URLSearchParams(location.search).get("q") ?? "")
+      : "",
+  );
 
+  React.useEffect(() => {
+    if (location.pathname === "/search") {
+      setSearchQuery(new URLSearchParams(location.search).get("q") ?? "");
+    }
+  }, [location.pathname, location.search]);
   return (
     <header className="sticky top-0 z-30 border-b border-border bg-surface/95 backdrop-blur">
       <nav className="flex h-14 items-center justify-between gap-2 px-4 sm:px-6">
@@ -292,7 +305,33 @@ export const AppHeader: React.FC = () => {
             ))}
           </div>
         </div>
-        <div className="shrink-0">
+        <div className="ml-auto flex min-w-0 items-center gap-2">
+          {status ? (
+            <form
+              className="hidden w-44 sm:block 2xl:w-56"
+              onSubmit={(event) => {
+                event.preventDefault();
+                const query = searchQuery.trim();
+                navigate(
+                  query ? `/search?q=${encodeURIComponent(query)}` : "/search",
+                );
+              }}
+            >
+              <label className="relative block">
+                <span className="sr-only">{t("nav.search")}</span>
+                <Search
+                  size={15}
+                  className="absolute left-2.5 top-2 text-subtle"
+                />
+                <input
+                  value={searchQuery}
+                  onChange={(event) => setSearchQuery(event.target.value)}
+                  placeholder={t("nav.searchPlaceholder")}
+                  className="w-full rounded-md border border-border bg-canvas py-1.5 pl-8 pr-2 text-sm text-foreground outline-hidden placeholder:text-subtle focus:border-focus focus:ring-2 focus:ring-focus"
+                />
+              </label>
+            </form>
+          ) : null}
           {status ? (
             <UserMenu />
           ) : (
diff --git a/SecondDimensionWatcherReDive.Client/src/components/SubscriptionPolicySheet.tsx b/SecondDimensionWatcherReDive.Client/src/components/SubscriptionPolicySheet.tsx
index d82c47a..7b91b98 100644
--- a/SecondDimensionWatcherReDive.Client/src/components/SubscriptionPolicySheet.tsx
+++ b/SecondDimensionWatcherReDive.Client/src/components/SubscriptionPolicySheet.tsx
@@ -138,6 +138,13 @@ export const SubscriptionPolicySheet: React.FC<
     draft.minSizeBytes != null &&
     draft.maxSizeBytes != null &&
     draft.minSizeBytes > draft.maxSizeBytes;
+  const upgradePolicyIsInvalid =
+    !Number.isInteger(draft.minimumUpgradeScore) ||
+    draft.minimumUpgradeScore < 1 ||
+    draft.minimumUpgradeScore > 1000 ||
+    !Number.isInteger(draft.upgradeRollbackHours) ||
+    draft.upgradeRollbackHours < 1 ||
+    draft.upgradeRollbackHours > 720;
 
   const updateDraft = React.useCallback(
     (update: React.SetStateAction<ISubscriptionPolicyDraft>) => {
@@ -161,7 +168,7 @@ export const SubscriptionPolicySheet: React.FC<
   );
 
   const handleSave = React.useCallback(async () => {
-    if (!feed || saving || sizeRangeIsInvalid) return;
+    if (!feed || saving || sizeRangeIsInvalid || upgradePolicyIsInvalid) return;
     setSaving(true);
     try {
       const saved = await saveSubscriptionPolicy(feed.id, draft);
@@ -180,7 +187,16 @@ export const SubscriptionPolicySheet: React.FC<
     } finally {
       setSaving(false);
     }
-  }, [feed, saving, sizeRangeIsInvalid, draft, onPolicyChanged, addToast, t]);
+  }, [
+    feed,
+    saving,
+    sizeRangeIsInvalid,
+    upgradePolicyIsInvalid,
+    draft,
+    onPolicyChanged,
+    addToast,
+    t,
+  ]);
 
   const handleDelete = React.useCallback(async () => {
     if (!feed || !hasSavedPolicy) return;
@@ -208,7 +224,8 @@ export const SubscriptionPolicySheet: React.FC<
   }, [feed, hasSavedPolicy, onPolicyChanged, addToast, t]);
 
   const handleSimulate = React.useCallback(async () => {
-    if (!feed || simulating || sizeRangeIsInvalid) return;
+    if (!feed || simulating || sizeRangeIsInvalid || upgradePolicyIsInvalid)
+      return;
     setSimulating(true);
     try {
       const result = await simulateSubscriptionPolicy(feed.id, draft);
@@ -221,7 +238,15 @@ export const SubscriptionPolicySheet: React.FC<
     } finally {
       setSimulating(false);
     }
-  }, [feed, simulating, sizeRangeIsInvalid, draft, addToast, t]);
+  }, [
+    feed,
+    simulating,
+    sizeRangeIsInvalid,
+    upgradePolicyIsInvalid,
+    draft,
+    addToast,
+    t,
+  ]);
 
   return (
     <Sheet open={feed != null} onOpenChange={onOpenChange}>
@@ -414,6 +439,85 @@ export const SubscriptionPolicySheet: React.FC<
                 </div>
               </section>
 
+              <section className="px-4 py-5 sm:px-6">
+                <SectionHeading
+                  number="03"
+                  title={t("automation.upgrades.title")}
+                  description={t("automation.upgrades.description")}
+                />
+                <label className="mt-4 flex cursor-pointer items-start gap-3 rounded-lg border border-border bg-canvas/60 p-4">
+                  <input
+                    type="checkbox"
+                    checked={draft.enableVersionUpgrade}
+                    onChange={(event) =>
+                      updateDraft((current) => ({
+                        ...current,
+                        enableVersionUpgrade: event.target.checked,
+                      }))
+                    }
+                    className="mt-1 h-4 w-4 accent-brand"
+                  />
+                  <span>
+                    <span className="block text-sm font-medium text-foreground">
+                      {t("automation.upgrades.enable")}
+                    </span>
+                    <span className="mt-0.5 block text-xs leading-body text-muted">
+                      {t("automation.upgrades.enableHelp")}
+                    </span>
+                  </span>
+                </label>
+                <div className="mt-4 grid gap-4 sm:grid-cols-2">
+                  <label className="text-sm font-medium text-foreground">
+                    {t("automation.upgrades.minimumScore")}
+                    <Input
+                      className="mt-1.5"
+                      type="number"
+                      min="1"
+                      max="1000"
+                      value={draft.minimumUpgradeScore}
+                      onChange={(event) =>
+                        updateDraft((current) => ({
+                          ...current,
+                          minimumUpgradeScore: Number(event.target.value),
+                        }))
+                      }
+                    />
+                    <span className="mt-1 block text-xs font-normal text-subtle">
+                      {t("automation.upgrades.minimumScoreHelp")}
+                    </span>
+                  </label>
+                  <label className="text-sm font-medium text-foreground">
+                    {t("automation.upgrades.rollbackHours")}
+                    <Input
+                      className="mt-1.5"
+                      type="number"
+                      min="1"
+                      max="720"
+                      value={draft.upgradeRollbackHours}
+                      onChange={(event) =>
+                        updateDraft((current) => ({
+                          ...current,
+                          upgradeRollbackHours: Number(event.target.value),
+                        }))
+                      }
+                    />
+                    <span className="mt-1 block text-xs font-normal text-subtle">
+                      {t("automation.upgrades.rollbackHoursHelp")}
+                    </span>
+                  </label>
+                </div>
+                {upgradePolicyIsInvalid ? (
+                  <p
+                    role="status"
+                    aria-live="polite"
+                    className="mt-2 flex items-center gap-1.5 text-xs text-error"
+                  >
+                    <CircleAlert size={13} />
+                    {t("automation.upgrades.rangeError")}
+                  </p>
+                ) : null}
+              </section>
+
               <section className="px-4 py-5 sm:px-6">
                 {simulating ? (
                   <span
@@ -427,14 +531,16 @@ export const SubscriptionPolicySheet: React.FC<
                 ) : null}
                 <div className="flex flex-wrap items-start justify-between gap-4">
                   <SectionHeading
-                    number="03"
+                    number="04"
                     title={t("automation.simulation.title")}
                     description={t("automation.simulation.description")}
                   />
                   <Button
                     variant="outline"
                     onClick={handleSimulate}
-                    disabled={simulating || sizeRangeIsInvalid}
+                    disabled={
+                      simulating || sizeRangeIsInvalid || upgradePolicyIsInvalid
+                    }
                   >
                     {simulating ? (
                       <Spinner className="h-4 w-4" />
@@ -490,7 +596,12 @@ export const SubscriptionPolicySheet: React.FC<
             <Button
               className="flex-1 sm:flex-none"
               onClick={handleSave}
-              disabled={saving || loading || sizeRangeIsInvalid}
+              disabled={
+                saving ||
+                loading ||
+                sizeRangeIsInvalid ||
+                upgradePolicyIsInvalid
+              }
             >
               {saving ? <Spinner className="h-4 w-4" /> : <Save size={16} />}
               {t("automation.actions.save")}
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/common.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/common.json
index 362b83a..65828d2 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/common.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/common.json
@@ -2,6 +2,8 @@
   "appName": "SDW Re:Dive",
   "nav": {
     "home": "Home",
+    "search": "Search",
+    "searchPlaceholder": "Search library…",
     "todo": "To-do center",
     "downloading": "Downloading",
     "downloaded": "Downloaded",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/feeds.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/feeds.json
index e1ae666..7ae3d28 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/feeds.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/feeds.json
@@ -97,6 +97,17 @@
         "placeholder": "For example, batch, NCOP, trailer"
       }
     },
+    "upgrades": {
+      "title": "Version upgrades",
+      "description": "Automatically claim a higher-scoring release, validate every new file, then atomically switch mappings while keeping rollback data.",
+      "enable": "Enable automatic version upgrades",
+      "enableHelp": "Only upgrades that beat the active release by the threshold below are started.",
+      "minimumScore": "Minimum score improvement",
+      "minimumScoreHelp": "Required difference between the candidate and current release (1–1000).",
+      "rollbackHours": "Rollback window (hours)",
+      "rollbackHoursHelp": "Old files and mapping snapshots are retained for this period (1–720 hours).",
+      "rangeError": "Score improvement must be 1–1000 and rollback window must be 1–720 hours."
+    },
     "simulation": {
       "title": "Simulate against history",
       "description": "Replay recent items with the current unsaved settings. This never sends notifications or creates downloads.",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/library.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/library.json
new file mode 100644
index 0000000..b5b1d5f
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/en/library.json
@@ -0,0 +1,71 @@
+{
+  "eyebrow": "Media intelligence",
+  "title": "Search the whole library",
+  "description": "Find releases across titles, episode metadata, download source, watch state, and virtual paths. Every filter is preserved in the URL.",
+  "queryLabel": "Search titles, aliases, groups, and paths",
+  "queryPlaceholder": "Title, alias, group, TMDB ID, or path…",
+  "search": "Search",
+  "filters": {
+    "title": "Filters ({{count}} active)",
+    "clear": "Clear all",
+    "season": "Season",
+    "episode": "Episode",
+    "subtitleGroup": "Release group",
+    "path": "Virtual path",
+    "resolution": "Resolution",
+    "codec": "Codec",
+    "language": "Language",
+    "downloadState": "Download state",
+    "watchState": "Watch state",
+    "source": "Source",
+    "sort": "Sort"
+  },
+  "values": {
+    "Any": "Any",
+    "NotDownloaded": "Not downloaded",
+    "Downloading": "Downloading",
+    "Downloaded": "Downloaded",
+    "Unwatched": "Unwatched",
+    "InProgress": "In progress",
+    "Watched": "Watched",
+    "Torrent": "Torrent",
+    "MediaLibraryImport": "Media import",
+    "PublishedDescending": "Newest first",
+    "TitleAscending": "Title A–Z",
+    "EpisodeAscending": "Episode order",
+    "ScoreDescending": "Best score"
+  },
+  "results": {
+    "title": "Search results",
+    "pageCount": "{{count}} on this page",
+    "empty": "No releases match these filters",
+    "error": "The library search could not be loaded",
+    "unidentified": "Unidentified",
+    "score": "release score",
+    "morePaths": "+{{count}} more paths",
+    "next": "Next page"
+  },
+  "integrity": {
+    "title": "Completeness and upgrades",
+    "description": "Missing, duplicate, and unidentified episodes plus higher-scoring releases.",
+    "refresh": "Refresh",
+    "season": "Season {{season}} · {{count}} expected",
+    "missing": "Missing",
+    "duplicates": "Duplicates",
+    "unidentified": "Unidentified"
+  },
+  "upgrade": {
+    "episode": "Episode {{episode}} upgrade",
+    "preview": "Dry run",
+    "apply": "Upgrade",
+    "confirm": "Validate and start this upgrade? The old files remain available during the rollback window.",
+    "previewNeedsDownload": "Dry run passed; the candidate must be downloaded",
+    "previewReady": "Dry run passed; candidate files are ready",
+    "failed": "The upgrade could not be started",
+    "outcomes": {
+      "download_queued": "Candidate download queued",
+      "applied": "Upgrade applied",
+      "already_applied": "Upgrade was already applied"
+    }
+  }
+}
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/common.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/common.json
index d2cc7ae..74a5827 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/common.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/common.json
@@ -2,6 +2,8 @@
   "appName": "SDW Re:Dive",
   "nav": {
     "home": "ホーム",
+    "search": "検索",
+    "searchPlaceholder": "ライブラリを検索…",
     "todo": "TODO センター",
     "downloading": "ダウンロード中",
     "downloaded": "ダウンロード済み",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/feeds.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/feeds.json
index e2f1471..364a9cc 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/feeds.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/feeds.json
@@ -97,6 +97,17 @@
         "placeholder": "例：一括、NCOP、予告"
       }
     },
+    "upgrades": {
+      "title": "バージョン更新",
+      "description": "高スコアのリリースを取得し、新ファイルを検証してからマッピングを原子的に切り替え、ロールバック情報を保持します。",
+      "enable": "自動バージョン更新を有効にする",
+      "enableHelp": "下記のしきい値以上にスコアが向上する候補だけを開始します。",
+      "minimumScore": "最小スコア向上値",
+      "minimumScoreHelp": "候補と現在のリリースに必要な差（1～1000）。",
+      "rollbackHours": "ロールバック期間（時間）",
+      "rollbackHoursHelp": "旧ファイルとマッピングのスナップショットを保持する期間（1～720時間）。",
+      "rangeError": "スコア差は1～1000、ロールバック期間は1～720時間で指定してください。"
+    },
     "simulation": {
       "title": "履歴でシミュレーション",
       "description": "現在の未保存設定で最近の項目を再判定します。通知やダウンロードは作成されません。",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/library.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/library.json
new file mode 100644
index 0000000..061b010
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/ja/library.json
@@ -0,0 +1,71 @@
+{
+  "eyebrow": "メディア管理",
+  "title": "ライブラリ全体を検索",
+  "description": "タイトル、話数、取得元、視聴状態、仮想パスを横断検索できます。フィルターは URL に保存されます。",
+  "queryLabel": "タイトル、別名、グループ、パスを検索",
+  "queryPlaceholder": "タイトル、別名、グループ、TMDB ID、パス…",
+  "search": "検索",
+  "filters": {
+    "title": "フィルター（{{count}} 件）",
+    "clear": "すべて解除",
+    "season": "シーズン",
+    "episode": "話数",
+    "subtitleGroup": "リリースグループ",
+    "path": "仮想パス",
+    "resolution": "解像度",
+    "codec": "コーデック",
+    "language": "言語",
+    "downloadState": "ダウンロード状態",
+    "watchState": "視聴状態",
+    "source": "取得元",
+    "sort": "並び順"
+  },
+  "values": {
+    "Any": "すべて",
+    "NotDownloaded": "未取得",
+    "Downloading": "取得中",
+    "Downloaded": "取得済み",
+    "Unwatched": "未視聴",
+    "InProgress": "視聴中",
+    "Watched": "視聴済み",
+    "Torrent": "Torrent",
+    "MediaLibraryImport": "メディア取込",
+    "PublishedDescending": "新しい順",
+    "TitleAscending": "タイトル順",
+    "EpisodeAscending": "話数順",
+    "ScoreDescending": "スコア順"
+  },
+  "results": {
+    "title": "検索結果",
+    "pageCount": "このページに {{count}} 件",
+    "empty": "条件に一致するリリースはありません",
+    "error": "ライブラリ検索を読み込めません",
+    "unidentified": "未識別",
+    "score": "リリーススコア",
+    "morePaths": "他 {{count}} 件のパス",
+    "next": "次のページ"
+  },
+  "integrity": {
+    "title": "完全性とアップグレード",
+    "description": "欠番、重複、未識別の話数と高スコア候補を確認します。",
+    "refresh": "更新",
+    "season": "シーズン {{season}} · 全 {{count}} 話予定",
+    "missing": "欠番",
+    "duplicates": "重複",
+    "unidentified": "未識別"
+  },
+  "upgrade": {
+    "episode": "第 {{episode}} 話を更新",
+    "preview": "ドライラン",
+    "apply": "更新",
+    "confirm": "検証して更新を開始しますか？旧ファイルはロールバック期間中保持されます。",
+    "previewNeedsDownload": "ドライラン成功：候補の取得が必要です",
+    "previewReady": "ドライラン成功：候補ファイルは準備済みです",
+    "failed": "更新を開始できませんでした",
+    "outcomes": {
+      "download_queued": "候補をダウンロード待ちに追加しました",
+      "applied": "更新を適用しました",
+      "already_applied": "更新は適用済みです"
+    }
+  }
+}
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/common.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/common.json
index 927a127..238a405 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/common.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/common.json
@@ -2,6 +2,8 @@
   "appName": "二次元观测器",
   "nav": {
     "home": "主页",
+    "search": "搜索",
+    "searchPlaceholder": "搜索媒体库…",
     "todo": "待办中心",
     "downloading": "下载列表",
     "downloaded": "已下载",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/feeds.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/feeds.json
index b757e15..f649add 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/feeds.json
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/feeds.json
@@ -97,6 +97,17 @@
         "placeholder": "例如 合集、NCOP、预告"
       }
     },
+    "upgrades": {
+      "title": "版本升级",
+      "description": "自动认领评分更高的 Release，逐个验证新文件后原子切换映射，并保留回滚数据。",
+      "enable": "启用自动版本升级",
+      "enableHelp": "只有评分提升达到下方阈值的候选版本才会自动开始。",
+      "minimumScore": "最低评分提升",
+      "minimumScoreHelp": "候选版本相对当前版本必须提升的分数（1–1000）。",
+      "rollbackHours": "回滚窗口（小时）",
+      "rollbackHoursHelp": "旧文件和映射快照会保留该时长（1–720 小时）。",
+      "rangeError": "评分提升须为 1–1000，回滚窗口须为 1–720 小时。"
+    },
     "simulation": {
       "title": "用历史条目模拟",
       "description": "以当前尚未保存的配置重放近期条目，不会发送通知或创建下载。",
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/library.json b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/library.json
new file mode 100644
index 0000000..822e9da
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/locales/zh-CN/library.json
@@ -0,0 +1,71 @@
+{
+  "eyebrow": "媒体库智能",
+  "title": "搜索整个媒体库",
+  "description": "跨标题、剧集元数据、下载来源、观看状态和虚拟路径检索；全部筛选条件都会保存在 URL 中。",
+  "queryLabel": "搜索标题、别名、字幕组和路径",
+  "queryPlaceholder": "标题、别名、字幕组、TMDB ID 或路径…",
+  "search": "搜索",
+  "filters": {
+    "title": "筛选（已启用 {{count}} 项）",
+    "clear": "全部清除",
+    "season": "季度",
+    "episode": "集数",
+    "subtitleGroup": "字幕组",
+    "path": "虚拟路径",
+    "resolution": "分辨率",
+    "codec": "编码",
+    "language": "语言",
+    "downloadState": "下载状态",
+    "watchState": "观看状态",
+    "source": "来源",
+    "sort": "排序"
+  },
+  "values": {
+    "Any": "不限",
+    "NotDownloaded": "未下载",
+    "Downloading": "下载中",
+    "Downloaded": "已下载",
+    "Unwatched": "未观看",
+    "InProgress": "观看中",
+    "Watched": "已看完",
+    "Torrent": "种子下载",
+    "MediaLibraryImport": "媒体库导入",
+    "PublishedDescending": "最新发布",
+    "TitleAscending": "标题升序",
+    "EpisodeAscending": "剧集顺序",
+    "ScoreDescending": "评分最高"
+  },
+  "results": {
+    "title": "搜索结果",
+    "pageCount": "本页 {{count}} 项",
+    "empty": "没有符合筛选条件的 Release",
+    "error": "无法加载媒体库搜索",
+    "unidentified": "未识别",
+    "score": "Release 评分",
+    "morePaths": "另有 {{count}} 个路径",
+    "next": "下一页"
+  },
+  "integrity": {
+    "title": "完整性与版本升级",
+    "description": "集中查看缺集、重复集、未识别剧集和评分更高的候选版本。",
+    "refresh": "刷新",
+    "season": "第 {{season}} 季 · 预计 {{count}} 集",
+    "missing": "缺集",
+    "duplicates": "重复",
+    "unidentified": "未识别"
+  },
+  "upgrade": {
+    "episode": "第 {{episode}} 集升级",
+    "preview": "预演",
+    "apply": "升级",
+    "confirm": "验证并启动该升级？旧文件会在回滚窗口内保留。",
+    "previewNeedsDownload": "预演通过；需要下载候选版本",
+    "previewReady": "预演通过；候选文件已就绪",
+    "failed": "无法启动版本升级",
+    "outcomes": {
+      "download_queued": "候选版本已加入下载",
+      "applied": "版本升级已应用",
+      "already_applied": "版本升级已应用"
+    }
+  }
+}
diff --git a/SecondDimensionWatcherReDive.Client/src/i18n/resources.ts b/SecondDimensionWatcherReDive.Client/src/i18n/resources.ts
index e73ac13..9ce2cc2 100644
--- a/SecondDimensionWatcherReDive.Client/src/i18n/resources.ts
+++ b/SecondDimensionWatcherReDive.Client/src/i18n/resources.ts
@@ -6,6 +6,7 @@ import enErrors from "./locales/en/errors.json";
 import enFeeds from "./locales/en/feeds.json";
 import enFiles from "./locales/en/files.json";
 import enIncidents from "./locales/en/incidents.json";
+import enLibrary from "./locales/en/library.json";
 import enMetadataReview from "./locales/en/metadataReview.json";
 import enPlayer from "./locales/en/player.json";
 import enSeason from "./locales/en/season.json";
@@ -20,6 +21,7 @@ import jaErrors from "./locales/ja/errors.json";
 import jaFeeds from "./locales/ja/feeds.json";
 import jaFiles from "./locales/ja/files.json";
 import jaIncidents from "./locales/ja/incidents.json";
+import jaLibrary from "./locales/ja/library.json";
 import jaMetadataReview from "./locales/ja/metadataReview.json";
 import jaPlayer from "./locales/ja/player.json";
 import jaSeason from "./locales/ja/season.json";
@@ -34,6 +36,7 @@ import zhCnErrors from "./locales/zh-CN/errors.json";
 import zhCnFeeds from "./locales/zh-CN/feeds.json";
 import zhCnFiles from "./locales/zh-CN/files.json";
 import zhCnIncidents from "./locales/zh-CN/incidents.json";
+import zhCnLibrary from "./locales/zh-CN/library.json";
 import zhCnMetadataReview from "./locales/zh-CN/metadataReview.json";
 import zhCnPlayer from "./locales/zh-CN/player.json";
 import zhCnSeason from "./locales/zh-CN/season.json";
@@ -52,6 +55,7 @@ export const resources = {
     chat: zhCnChat,
     feeds: zhCnFeeds,
     incidents: zhCnIncidents,
+    library: zhCnLibrary,
     season: zhCnSeason,
     settings: zhCnSettings,
     tasks: zhCnTasks,
@@ -68,6 +72,7 @@ export const resources = {
     chat: enChat,
     feeds: enFeeds,
     incidents: enIncidents,
+    library: enLibrary,
     season: enSeason,
     settings: enSettings,
     tasks: enTasks,
@@ -84,6 +89,7 @@ export const resources = {
     chat: jaChat,
     feeds: jaFeeds,
     incidents: jaIncidents,
+    library: jaLibrary,
     season: jaSeason,
     settings: jaSettings,
     tasks: jaTasks,
diff --git a/SecondDimensionWatcherReDive.Client/src/library/api.ts b/SecondDimensionWatcherReDive.Client/src/library/api.ts
new file mode 100644
index 0000000..9c131c5
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/library/api.ts
@@ -0,0 +1,36 @@
+import useSWR from "swr";
+
+import fetcher from "../auth/httpClient";
+import {
+  LibraryIntegritySummary,
+  LibrarySearchResult,
+  ReleaseUpgradeCandidate,
+  ReleaseUpgradeExecutionResult,
+} from "./types";
+
+export const useLibrarySearch = (params: URLSearchParams) => {
+  const query = params.toString();
+  return useSWR<LibrarySearchResult>(`/api/library/search?${query}`, fetcher, {
+    keepPreviousData: true,
+  });
+};
+
+export const useLibraryIntegrity = () =>
+  useSWR<LibraryIntegritySummary[]>("/api/library/integrity", fetcher);
+
+export const executeReleaseUpgrade = async (
+  candidate: ReleaseUpgradeCandidate,
+  dryRun: boolean,
+) =>
+  await fetcher<ReleaseUpgradeExecutionResult>(
+    "/api/library/upgrades/execute",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        currentReleaseId: candidate.currentReleaseId,
+        candidateReleaseId: candidate.candidateReleaseId,
+        dryRun,
+      }),
+    },
+  );
diff --git a/SecondDimensionWatcherReDive.Client/src/library/types.ts b/SecondDimensionWatcherReDive.Client/src/library/types.ts
new file mode 100644
index 0000000..c0782f8
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/library/types.ts
@@ -0,0 +1,69 @@
+export type LibraryDownloadState =
+  "Any" | "NotDownloaded" | "Downloading" | "Downloaded";
+export type LibraryWatchState = "Any" | "Unwatched" | "InProgress" | "Watched";
+export type LibrarySourceKind = "Any" | "Torrent" | "MediaLibraryImport";
+export type LibrarySearchSort =
+  | "PublishedDescending"
+  | "TitleAscending"
+  | "EpisodeAscending"
+  | "ScoreDescending";
+
+export interface LibrarySearchItem {
+  animationInfoId: string;
+  title: string;
+  animationName: string | null;
+  animationOriginalName: string | null;
+  tmdbId: string | null;
+  season: number | null;
+  episode: number | null;
+  subtitleGroup: string | null;
+  resolution: string | null;
+  codec: string | null;
+  languages: string[];
+  isDownloadTracked: boolean;
+  isDownloadFinished: boolean;
+  isMediaLibraryImport: boolean;
+  isWatched: boolean;
+  playbackPositionSeconds: number | null;
+  virtualPaths: string[];
+  virtualPathCount: number;
+  releaseScore: number;
+  scoreReasons: string[];
+  publishedAt: string;
+}
+
+export interface LibrarySearchResult {
+  items: LibrarySearchItem[];
+  nextCursor: string | null;
+}
+
+export interface ReleaseUpgradeCandidate {
+  currentReleaseId: string;
+  candidateReleaseId: string;
+  animationName: string;
+  season: number;
+  episode: number;
+  currentScore: number;
+  candidateScore: number;
+  scoreReasons: string[];
+  automatic: boolean;
+}
+
+export interface LibraryIntegritySummary {
+  tmdbId: string;
+  animationName: string;
+  season: number;
+  expectedEpisodeCount: number | null;
+  missingEpisodes: number[];
+  duplicateEpisodes: Array<{ episode: number; releaseIds: string[] }>;
+  unidentifiedReleaseCount: number;
+  upgradeCandidates: ReleaseUpgradeCandidate[];
+}
+
+export interface ReleaseUpgradeExecutionResult {
+  isSuccess: boolean;
+  outcome: string;
+  dryRun: boolean;
+  requiresDownload: boolean;
+  validationErrors: string[];
+}
diff --git a/SecondDimensionWatcherReDive.Client/src/pages/SearchPage.tsx b/SecondDimensionWatcherReDive.Client/src/pages/SearchPage.tsx
new file mode 100644
index 0000000..6d7191d
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Client/src/pages/SearchPage.tsx
@@ -0,0 +1,564 @@
+import React from "react";
+import { useTranslation } from "react-i18next";
+import { useSearchParams } from "react-router";
+
+import {
+  AlertTriangle,
+  CheckCircle2,
+  ChevronRight,
+  Download,
+  FileQuestion,
+  RefreshCw,
+  Search,
+} from "lucide-react";
+
+import { useToast } from "../components/ToastProvider";
+import { Button } from "../components/ui/Button";
+import { EmptyPrompt } from "../components/ui/EmptyPrompt";
+import { Input } from "../components/ui/Input";
+import { Spinner } from "../components/ui/Spinner";
+import { ApiError } from "../errors/apiError";
+import { cn } from "../lib/cn";
+import {
+  executeReleaseUpgrade,
+  useLibraryIntegrity,
+  useLibrarySearch,
+} from "../library/api";
+import { ReleaseUpgradeCandidate } from "../library/types";
+import { PageTemplate } from "./PageTemplate";
+
+const FILTER_KEYS = [
+  "season",
+  "episode",
+  "subtitleGroup",
+  "resolution",
+  "codec",
+  "language",
+  "downloadState",
+  "watchState",
+  "path",
+  "source",
+  "sort",
+] as const;
+
+const selectClass =
+  "w-full rounded-lg border border-border bg-surface px-3 py-2 text-sm text-foreground focus:border-focus focus:outline-hidden focus:ring-2 focus:ring-focus";
+
+export const SearchPage: React.FC = () => {
+  const { t } = useTranslation("library");
+  const { addToast } = useToast();
+  const [params, setParams] = useSearchParams();
+  const [query, setQuery] = React.useState(params.get("q") ?? "");
+  const [runningUpgrade, setRunningUpgrade] = React.useState<string | null>(
+    null,
+  );
+  const { data, error, isLoading } = useLibrarySearch(params);
+  const { data: integrity, mutate: refreshIntegrity } = useLibraryIntegrity();
+
+  React.useEffect(() => setQuery(params.get("q") ?? ""), [params]);
+
+  React.useEffect(() => {
+    if (
+      !params.has("cursor") ||
+      !(error instanceof ApiError) ||
+      error.code !== "library_cursor_invalidated"
+    )
+      return;
+
+    const next = new URLSearchParams(params);
+    next.delete("cursor");
+    setParams(next, { replace: true });
+  }, [error, params, setParams]);
+
+  const setFilter = React.useCallback(
+    (key: string, value: string) => {
+      const next = new URLSearchParams(params);
+      if (value) next.set(key, value);
+      else next.delete(key);
+      if (key !== "cursor") next.delete("cursor");
+      setParams(next, { replace: true });
+    },
+    [params, setParams],
+  );
+
+  const submitQuery = (event: React.FormEvent) => {
+    event.preventDefault();
+    setFilter("q", query.trim());
+  };
+
+  const clearFilters = () => {
+    setQuery("");
+    setParams(new URLSearchParams(), { replace: true });
+  };
+
+  const runUpgrade = async (
+    candidate: ReleaseUpgradeCandidate,
+    dryRun: boolean,
+  ) => {
+    if (!dryRun && !window.confirm(t("upgrade.confirm"))) return;
+    setRunningUpgrade(candidate.candidateReleaseId);
+    try {
+      const result = await executeReleaseUpgrade(candidate, dryRun);
+      addToast({
+        title: dryRun
+          ? result.requiresDownload
+            ? t("upgrade.previewNeedsDownload")
+            : t("upgrade.previewReady")
+          : t(`upgrade.outcomes.${result.outcome}`, {
+              defaultValue: result.outcome,
+            }),
+        color: result.isSuccess ? "success" : "danger",
+      });
+      if (!dryRun) await refreshIntegrity();
+    } catch {
+      addToast({ title: t("upgrade.failed"), color: "danger" });
+    } finally {
+      setRunningUpgrade(null);
+    }
+  };
+
+  const activeFilterCount = FILTER_KEYS.filter((key) => params.has(key)).length;
+
+  return (
+    <PageTemplate>
+      <header className="mb-7 max-w-3xl">
+        <p className="font-mono text-xs uppercase tracking-[0.18em] text-brand">
+          {t("eyebrow")}
+        </p>
+        <h1 className="mt-2 font-serif text-3xl font-medium text-foreground">
+          {t("title")}
+        </h1>
+        <p className="mt-2 text-sm leading-body text-muted">
+          {t("description")}
+        </p>
+      </header>
+
+      <form onSubmit={submitQuery} className="flex gap-2">
+        <div className="relative flex-1">
+          <Search className="absolute left-3 top-2.5 text-subtle" size={18} />
+          <Input
+            value={query}
+            onChange={(event) => setQuery(event.target.value)}
+            className="pl-10"
+            placeholder={t("queryPlaceholder")}
+            aria-label={t("queryLabel")}
+          />
+        </div>
+        <Button type="submit">{t("search")}</Button>
+      </form>
+
+      <section className="mt-4 rounded-xl border border-border-light bg-surface p-4 shadow-whisper">
+        <div className="mb-3 flex items-center justify-between gap-3">
+          <h2 className="text-sm font-medium text-foreground">
+            {t("filters.title", { count: activeFilterCount })}
+          </h2>
+          <button
+            type="button"
+            onClick={clearFilters}
+            className="text-xs text-brand hover:underline"
+          >
+            {t("filters.clear")}
+          </button>
+        </div>
+        <div className="grid gap-3 sm:grid-cols-2 lg:grid-cols-4">
+          <FilterInput
+            label={t("filters.season")}
+            name="season"
+            params={params}
+            onChange={setFilter}
+            type="number"
+          />
+          <FilterInput
+            label={t("filters.episode")}
+            name="episode"
+            params={params}
+            onChange={setFilter}
+            type="number"
+          />
+          <FilterInput
+            label={t("filters.subtitleGroup")}
+            name="subtitleGroup"
+            params={params}
+            onChange={setFilter}
+          />
+          <FilterInput
+            label={t("filters.path")}
+            name="path"
+            params={params}
+            onChange={setFilter}
+          />
+          <FilterInput
+            label={t("filters.resolution")}
+            name="resolution"
+            params={params}
+            onChange={setFilter}
+          />
+          <FilterInput
+            label={t("filters.codec")}
+            name="codec"
+            params={params}
+            onChange={setFilter}
+          />
+          <FilterInput
+            label={t("filters.language")}
+            name="language"
+            params={params}
+            onChange={setFilter}
+          />
+          <FilterSelect
+            label={t("filters.downloadState")}
+            name="downloadState"
+            params={params}
+            onChange={setFilter}
+            options={["Any", "NotDownloaded", "Downloading", "Downloaded"]}
+            t={t}
+          />
+          <FilterSelect
+            label={t("filters.watchState")}
+            name="watchState"
+            params={params}
+            onChange={setFilter}
+            options={["Any", "Unwatched", "InProgress", "Watched"]}
+            t={t}
+          />
+          <FilterSelect
+            label={t("filters.source")}
+            name="source"
+            params={params}
+            onChange={setFilter}
+            options={["Any", "Torrent", "MediaLibraryImport"]}
+            t={t}
+          />
+          <FilterSelect
+            label={t("filters.sort")}
+            name="sort"
+            params={params}
+            onChange={setFilter}
+            options={[
+              "PublishedDescending",
+              "TitleAscending",
+              "EpisodeAscending",
+              "ScoreDescending",
+            ]}
+            t={t}
+          />
+        </div>
+      </section>
+
+      <section className="mt-8">
+        <div className="mb-3 flex items-end justify-between gap-3">
+          <h2 className="font-serif text-xl font-medium text-foreground">
+            {t("results.title")}
+          </h2>
+          {data ? (
+            <span className="text-xs text-subtle">
+              {t("results.pageCount", { count: data.items.length })}
+            </span>
+          ) : null}
+        </div>
+        {isLoading ? (
+          <div className="flex justify-center py-16">
+            <Spinner />
+          </div>
+        ) : error ? (
+          <EmptyPrompt icon={<AlertTriangle />} title={t("results.error")} />
+        ) : !data?.items.length ? (
+          <EmptyPrompt icon={<FileQuestion />} title={t("results.empty")} />
+        ) : (
+          <div className="divide-y divide-border-light overflow-hidden rounded-xl border border-border bg-surface shadow-whisper">
+            {data.items.map((item) => (
+              <article key={item.animationInfoId} className="p-4 sm:p-5">
+                <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+                  <div className="min-w-0">
+                    <div className="flex flex-wrap items-center gap-2 text-xs text-subtle">
+                      <span className="rounded-full bg-brand/10 px-2 py-0.5 text-brand">
+                        {item.season != null && item.episode != null
+                          ? `S${String(item.season).padStart(2, "0")}E${String(item.episode).padStart(2, "0")}`
+                          : t("results.unidentified")}
+                      </span>
+                      <span>
+                        {item.isMediaLibraryImport
+                          ? t("values.MediaLibraryImport")
+                          : t("values.Torrent")}
+                      </span>
+                      <span>
+                        {new Date(item.publishedAt).toLocaleDateString()}
+                      </span>
+                    </div>
+                    <h3 className="mt-2 font-serif text-lg font-medium text-foreground">
+                      {item.animationName ?? item.title}
+                    </h3>
+                    {item.animationOriginalName ? (
+                      <p className="text-sm text-muted">
+                        {item.animationOriginalName}
+                      </p>
+                    ) : null}
+                    <div className="mt-2 flex flex-wrap gap-1.5 text-xs text-muted">
+                      {[
+                        item.subtitleGroup,
+                        item.resolution,
+                        item.codec,
+                        ...item.languages,
+                      ]
+                        .filter(Boolean)
+                        .map((value) => (
+                          <span
+                            key={value}
+                            className="rounded bg-canvas px-2 py-1"
+                          >
+                            {value}
+                          </span>
+                        ))}
+                    </div>
+                    {item.virtualPaths.map((path) => (
+                      <p
+                        key={path}
+                        className="mt-2 break-all font-mono text-xs text-subtle"
+                      >
+                        {path}
+                      </p>
+                    ))}
+                    {item.virtualPathCount > item.virtualPaths.length ? (
+                      <p className="mt-2 text-xs text-subtle">
+                        {t("results.morePaths", {
+                          count:
+                            item.virtualPathCount - item.virtualPaths.length,
+                        })}
+                      </p>
+                    ) : null}
+                  </div>
+                  <div className="shrink-0 text-left sm:text-right">
+                    <p className="font-mono text-lg font-medium text-foreground">
+                      {item.releaseScore}
+                    </p>
+                    <p className="text-xs text-subtle">{t("results.score")}</p>
+                    <p
+                      className={cn(
+                        "mt-2 text-xs",
+                        item.isDownloadFinished ? "text-success" : "text-muted",
+                      )}
+                    >
+                      {item.isDownloadFinished
+                        ? t("values.Downloaded")
+                        : item.isDownloadTracked
+                          ? t("values.Downloading")
+                          : t("values.NotDownloaded")}
+                    </p>
+                  </div>
+                </div>
+                {item.scoreReasons.length ? (
+                  <ul className="mt-3 flex flex-wrap gap-x-4 gap-y-1 text-xs text-subtle">
+                    {item.scoreReasons.map((reason) => (
+                      <li key={reason}>+ {reason}</li>
+                    ))}
+                  </ul>
+                ) : null}
+              </article>
+            ))}
+          </div>
+        )}
+        {data?.nextCursor ? (
+          <div className="mt-4 flex justify-end">
+            <Button
+              variant="outline"
+              onClick={() => setFilter("cursor", data.nextCursor!)}
+            >
+              {t("results.next")} <ChevronRight size={16} />
+            </Button>
+          </div>
+        ) : null}
+      </section>
+
+      <section className="mt-12">
+        <div className="mb-4 flex items-end justify-between gap-3">
+          <div>
+            <h2 className="font-serif text-xl font-medium text-foreground">
+              {t("integrity.title")}
+            </h2>
+            <p className="mt-1 text-sm text-muted">
+              {t("integrity.description")}
+            </p>
+          </div>
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={() => void refreshIntegrity()}
+          >
+            <RefreshCw size={15} /> {t("integrity.refresh")}
+          </Button>
+        </div>
+        <div className="grid gap-4 lg:grid-cols-2">
+          {integrity
+            ?.filter(
+              (item) =>
+                item.missingEpisodes.length ||
+                item.duplicateEpisodes.length ||
+                item.unidentifiedReleaseCount ||
+                item.upgradeCandidates.length,
+            )
+            .map((item) => (
+              <article
+                key={`${item.tmdbId}-${item.season}`}
+                className="rounded-xl border border-border bg-surface p-5 shadow-whisper"
+              >
+                <div className="flex items-start justify-between gap-3">
+                  <div>
+                    <h3 className="font-serif text-lg font-medium text-foreground">
+                      {item.animationName}
+                    </h3>
+                    <p className="text-xs text-subtle">
+                      {t("integrity.season", {
+                        season: item.season,
+                        count: item.expectedEpisodeCount ?? "?",
+                      })}
+                    </p>
+                  </div>
+                  {item.missingEpisodes.length === 0 &&
+                  item.duplicateEpisodes.length === 0 &&
+                  item.unidentifiedReleaseCount === 0 ? (
+                    <CheckCircle2 className="text-success" size={20} />
+                  ) : (
+                    <AlertTriangle className="text-warning" size={20} />
+                  )}
+                </div>
+                <dl className="mt-4 grid grid-cols-3 gap-3 text-center">
+                  <Metric
+                    label={t("integrity.missing")}
+                    value={item.missingEpisodes.join(", ") || "—"}
+                  />
+                  <Metric
+                    label={t("integrity.duplicates")}
+                    value={
+                      item.duplicateEpisodes
+                        .map((entry) => entry.episode)
+                        .join(", ") || "—"
+                    }
+                  />
+                  <Metric
+                    label={t("integrity.unidentified")}
+                    value={String(item.unidentifiedReleaseCount)}
+                  />
+                </dl>
+                {item.upgradeCandidates.map((candidate) => (
+                  <div
+                    key={candidate.candidateReleaseId}
+                    className="mt-4 rounded-lg border border-border-light bg-canvas/50 p-3"
+                  >
+                    <div className="flex flex-wrap items-center justify-between gap-2">
+                      <div>
+                        <p className="text-sm font-medium text-foreground">
+                          {t("upgrade.episode", { episode: candidate.episode })}
+                        </p>
+                        <p className="text-xs text-muted">
+                          {candidate.currentScore} → {candidate.candidateScore}{" "}
+                          (+{candidate.candidateScore - candidate.currentScore})
+                        </p>
+                      </div>
+                      <div className="flex gap-2">
+                        <Button
+                          variant="outline"
+                          size="sm"
+                          disabled={
+                            runningUpgrade === candidate.candidateReleaseId
+                          }
+                          onClick={() => void runUpgrade(candidate, true)}
+                        >
+                          {t("upgrade.preview")}
+                        </Button>
+                        <Button
+                          size="sm"
+                          disabled={
+                            runningUpgrade === candidate.candidateReleaseId
+                          }
+                          onClick={() => void runUpgrade(candidate, false)}
+                        >
+                          {runningUpgrade === candidate.candidateReleaseId ? (
+                            <Spinner className="h-4 w-4" />
+                          ) : (
+                            <Download size={14} />
+                          )}
+                          {t("upgrade.apply")}
+                        </Button>
+                      </div>
+                    </div>
+                    <ul className="mt-2 text-xs text-subtle">
+                      {candidate.scoreReasons.map((reason) => (
+                        <li key={reason}>+ {reason}</li>
+                      ))}
+                    </ul>
+                  </div>
+                ))}
+              </article>
+            ))}
+        </div>
+      </section>
+    </PageTemplate>
+  );
+};
+
+const FilterInput: React.FC<{
+  label: string;
+  name: string;
+  params: URLSearchParams;
+  onChange: (name: string, value: string) => void;
+  type?: string;
+}> = ({ label, name, params, onChange, type = "text" }) => (
+  <label className="text-xs text-muted">
+    {label}
+    <Input
+      key={`${name}-${params.get(name) ?? ""}`}
+      type={type}
+      min={type === "number" ? 0 : undefined}
+      defaultValue={params.get(name) ?? ""}
+      className="mt-1"
+      onBlur={(event) => onChange(name, event.target.value.trim())}
+      onKeyDown={(event) => {
+        if (event.key === "Enter") {
+          event.preventDefault();
+          onChange(name, event.currentTarget.value.trim());
+        }
+      }}
+    />
+  </label>
+);
+
+const FilterSelect: React.FC<{
+  label: string;
+  name: string;
+  params: URLSearchParams;
+  onChange: (name: string, value: string) => void;
+  options: string[];
+  t: (key: string) => string;
+}> = ({ label, name, params, onChange, options, t }) => (
+  <label className="text-xs text-muted">
+    {label}
+    <select
+      className={`${selectClass} mt-1`}
+      value={params.get(name) ?? options[0]}
+      onChange={(event) =>
+        onChange(
+          name,
+          event.target.value === options[0] ? "" : event.target.value,
+        )
+      }
+    >
+      {options.map((option) => (
+        <option key={option} value={option}>
+          {t(`values.${option}`)}
+        </option>
+      ))}
+    </select>
+  </label>
+);
+
+const Metric: React.FC<{ label: string; value: string }> = ({
+  label,
+  value,
+}) => (
+  <div className="rounded-lg bg-canvas px-2 py-3">
+    <dt className="text-xs text-subtle">{label}</dt>
+    <dd className="mt-1 break-words font-mono text-sm text-foreground">
+      {value}
+    </dd>
+  </div>
+);
diff --git a/SecondDimensionWatcherReDive.Client/src/routes/pageLoaders.ts b/SecondDimensionWatcherReDive.Client/src/routes/pageLoaders.ts
index 7cc613c..e2b667a 100644
--- a/SecondDimensionWatcherReDive.Client/src/routes/pageLoaders.ts
+++ b/SecondDimensionWatcherReDive.Client/src/routes/pageLoaders.ts
@@ -3,6 +3,7 @@ export const loadDownloadingPage = () => import("../pages/DownloadingPage");
 export const loadDownloadedPage = () => import("../pages/DownloadedPage");
 export const loadFilesPage = () => import("../pages/FilesPage");
 export const loadPlayerPage = () => import("../pages/PlayerPage");
+export const loadSearchPage = () => import("../pages/SearchPage");
 export const loadIncidentsPage = () => import("../pages/IncidentsPage");
 export const loadFeedsPage = () => import("../pages/FeedsPage");
 export const loadTasksPage = () => import("../pages/TasksPage");
diff --git a/SecondDimensionWatcherReDive.Client/src/subscriptionPolicy/types.ts b/SecondDimensionWatcherReDive.Client/src/subscriptionPolicy/types.ts
index 620b192..2ca20d9 100644
--- a/SecondDimensionWatcherReDive.Client/src/subscriptionPolicy/types.ts
+++ b/SecondDimensionWatcherReDive.Client/src/subscriptionPolicy/types.ts
@@ -10,6 +10,9 @@ export interface ISubscriptionPolicyDraft {
   maxSizeBytes: number | null;
   excludedKeywords: string[];
   mode: SubscriptionPolicyMode;
+  enableVersionUpgrade: boolean;
+  minimumUpgradeScore: number;
+  upgradeRollbackHours: number;
 }
 
 export interface ISubscriptionPolicy extends ISubscriptionPolicyDraft {
@@ -49,6 +52,9 @@ export const createEmptySubscriptionPolicy = (): ISubscriptionPolicyDraft => ({
   maxSizeBytes: null,
   excludedKeywords: [],
   mode: "ManualConfirm",
+  enableVersionUpgrade: false,
+  minimumUpgradeScore: 25,
+  upgradeRollbackHours: 72,
 });
 
 export const toSubscriptionPolicyDraft = (
@@ -62,4 +68,7 @@ export const toSubscriptionPolicyDraft = (
   maxSizeBytes: policy.maxSizeBytes,
   excludedKeywords: [...policy.excludedKeywords],
   mode: policy.mode,
+  enableVersionUpgrade: policy.enableVersionUpgrade ?? false,
+  minimumUpgradeScore: policy.minimumUpgradeScore ?? 25,
+  upgradeRollbackHours: policy.upgradeRollbackHours ?? 72,
 });
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/AnimationInfo.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/AnimationInfo.cs
index e02fed8..d15d21c 100644
--- a/SecondDimensionWatcherReDive.Framework/DataRepository/AnimationInfo.cs
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/AnimationInfo.cs
@@ -34,4 +34,17 @@ public sealed record AnimationInfo(
     Guid? DownloadAttemptId = null,
     Guid? DownloadCancellationId = null,
     Guid? MediaLibrarySourceId = null,
-    DateTimeOffset? MediaLibraryMissingSince = null);
+    DateTimeOffset? MediaLibraryMissingSince = null,
+    string? ReleaseIdentity = null,
+    string? FeedItemGuid = null,
+    string? EnclosureId = null,
+    string? TorrentInfoHash = null,
+    string? ReleaseSubtitleGroup = null,
+    string? ReleaseResolution = null,
+    string? ReleaseCodec = null,
+    IReadOnlyList<string>? ReleaseLanguages = null,
+    int ReleaseScore = 0,
+    string? ReleaseScoreReasonsJson = null,
+    int? ExpectedEpisodeCount = null,
+    DateTimeOffset? IngestedAt = null,
+    bool IsActiveRelease = false);
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/DuplicateReleaseException.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/DuplicateReleaseException.cs
new file mode 100644
index 0000000..e5951e8
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/DuplicateReleaseException.cs
@@ -0,0 +1,7 @@
+namespace SecondDimensionWatcherReDive.Framework.DataRepository;
+
+public sealed class DuplicateReleaseException(string releaseIdentity, Exception innerException)
+    : Exception("The release already exists.", innerException)
+{
+    public string ReleaseIdentity { get; } = releaseIdentity;
+}
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/IAnimationInfoRepository.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/IAnimationInfoRepository.cs
index 266ef8f..d01f16f 100644
--- a/SecondDimensionWatcherReDive.Framework/DataRepository/IAnimationInfoRepository.cs
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/IAnimationInfoRepository.cs
@@ -1,5 +1,23 @@
 namespace SecondDimensionWatcherReDive.Framework.DataRepository;
 
+public sealed record DownloadCancellationLease(
+    Guid Id,
+    DateTimeOffset ExpiresAt,
+    bool RemoveFile);
+
+public sealed record DownloadSubmissionLease(
+    Guid Id,
+    DateTimeOffset ExpiresAt);
+
+public sealed record PendingDownloadCancellation(
+    Guid AnimationInfoId,
+    bool RemoveFile);
+
+public sealed record PendingDownloadSubmission(
+    Guid AnimationInfoId,
+    Guid DownloadAttemptId,
+    Guid SubmissionLeaseId);
+
 public interface IAnimationInfoRepository
 {
     Task<PagedResult<AnimationInfo>> GetPagedAsync(int skip, int take, CancellationToken cancellationToken);
@@ -77,21 +95,67 @@ Task<IReadOnlyList<AnimationInfo>> GetDownloadedWithoutFileMappingsAsync(
 
     Task<AnimationInfo?> FindByTitleAsync(string title, CancellationToken cancellationToken);
 
+    Task<bool> ExistsReleaseSourceAsync(
+        Guid? sourceFeedId,
+        string? feedItemGuid,
+        string? enclosureId,
+        string downloadUrl,
+        CancellationToken cancellationToken);
+
     Task AddAsync(AnimationInfo info, CancellationToken cancellationToken);
 
     Task UpdateAsync(AnimationInfo info, CancellationToken cancellationToken);
 
-    Task<bool> TryStartDownloadAsync(
+    Task<DownloadSubmissionLease?> TryStartDownloadAsync(
         Guid id,
         Guid downloadAttemptId,
+        Guid submissionLeaseId,
+        TimeSpan submissionLeaseDuration,
         DateTimeOffset startedAt,
         SubscriptionAutomationDisposition? queuedDisposition,
         CancellationToken cancellationToken);
 
-    Task<bool> TryBeginCancelDownloadAsync(
+    Task<bool> TryMarkDownloadSubmittedAsync(
+        Guid id,
+        Guid downloadAttemptId,
+        Guid submissionLeaseId,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<PendingDownloadSubmission>> GetPendingDownloadSubmissionsAsync(
+        int take,
+        CancellationToken cancellationToken);
+
+    Task<bool> TryStartUpgradeDownloadAsync(
+        Guid id,
+        Guid releaseUpgradeOperationId,
+        Guid downloadAttemptId,
+        DateTimeOffset startedAt,
+        SubscriptionAutomationDisposition? queuedDisposition,
+        CancellationToken cancellationToken);
+
+    Task<DownloadCancellationLease?> TryBeginCancelDownloadAsync(
         Guid id,
         Guid? downloadAttemptId,
         Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        TimeSpan cancellationLeaseDuration,
+        bool removeFile,
+        bool requireUnfinished,
+        SubscriptionAutomationDisposition? terminalDisposition,
+        CancellationToken cancellationToken);
+
+    Task<DownloadCancellationLease?> TryBeginExpiredDownloadSubmissionRecoveryAsync(
+        Guid id,
+        Guid downloadAttemptId,
+        Guid observedSubmissionLeaseId,
+        Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        TimeSpan cancellationLeaseDuration,
+        SubscriptionAutomationDisposition? terminalDisposition,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<PendingDownloadCancellation>> GetPendingDownloadCancellationsAsync(
+        int take,
         CancellationToken cancellationToken);
 
     Task<AnimationInfo?> TryCompleteDownloadAsync(
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/IFileMappingRepository.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/IFileMappingRepository.cs
index 8d894ef..801fb06 100644
--- a/SecondDimensionWatcherReDive.Framework/DataRepository/IFileMappingRepository.cs
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/IFileMappingRepository.cs
@@ -87,6 +87,8 @@ Task<bool> TryFinalizeDownloadCancellationAsync(
         Guid animationInfoId,
         Guid? downloadAttemptId,
         Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        SubscriptionAutomationDisposition? terminalDisposition,
         CancellationToken cancellationToken);
 
     Task RemoveByAnimationInfoAsync(Guid animationInfoId, CancellationToken cancellationToken);
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/ILibrarySearchRepository.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/ILibrarySearchRepository.cs
new file mode 100644
index 0000000..eb7bd3a
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/ILibrarySearchRepository.cs
@@ -0,0 +1,13 @@
+namespace SecondDimensionWatcherReDive.Framework.DataRepository;
+
+public interface ILibrarySearchRepository
+{
+    Task<LibrarySearchResult> SearchAsync(
+        LibrarySearchRequest request,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<LibraryIntegritySummary>> GetIntegrityAsync(
+        string? tmdbId,
+        int? season,
+        CancellationToken cancellationToken);
+}
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/LibrarySearch.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/LibrarySearch.cs
new file mode 100644
index 0000000..529db30
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/LibrarySearch.cs
@@ -0,0 +1,101 @@
+namespace SecondDimensionWatcherReDive.Framework.DataRepository;
+
+public enum LibraryDownloadState
+{
+    Any,
+    NotDownloaded,
+    Downloading,
+    Downloaded
+}
+
+public enum LibraryWatchState
+{
+    Any,
+    Unwatched,
+    InProgress,
+    Watched
+}
+
+public enum LibrarySourceKind
+{
+    Any,
+    Torrent,
+    MediaLibraryImport
+}
+
+public enum LibrarySearchSort
+{
+    PublishedDescending,
+    TitleAscending,
+    EpisodeAscending,
+    ScoreDescending
+}
+
+public sealed record LibrarySearchRequest(
+    string? Query,
+    int? Season,
+    int? Episode,
+    string? SubtitleGroup,
+    string? Resolution,
+    string? Codec,
+    string? Language,
+    LibraryDownloadState DownloadState,
+    LibraryWatchState WatchState,
+    string? VirtualPath,
+    LibrarySourceKind Source,
+    LibrarySearchSort Sort,
+    string? Cursor,
+    int Take,
+    Guid UserId);
+
+public sealed record LibrarySearchItem(
+    Guid AnimationInfoId,
+    string Title,
+    string? AnimationName,
+    string? AnimationOriginalName,
+    string? TmdbId,
+    int? Season,
+    int? Episode,
+    string? SubtitleGroup,
+    string? Resolution,
+    string? Codec,
+    IReadOnlyList<string> Languages,
+    bool IsDownloadTracked,
+    bool IsDownloadFinished,
+    bool IsMediaLibraryImport,
+    bool IsWatched,
+    double? PlaybackPositionSeconds,
+    IReadOnlyList<string> VirtualPaths,
+    long VirtualPathCount,
+    int ReleaseScore,
+    IReadOnlyList<string> ScoreReasons,
+    DateTimeOffset PublishedAt);
+
+public sealed record LibrarySearchResult(
+    IReadOnlyList<LibrarySearchItem> Items,
+    string? NextCursor);
+
+public sealed record EpisodeDuplicate(
+    int Episode,
+    IReadOnlyList<Guid> ReleaseIds);
+
+public sealed record ReleaseUpgradeCandidate(
+    Guid CurrentReleaseId,
+    Guid CandidateReleaseId,
+    string AnimationName,
+    int Season,
+    int Episode,
+    int CurrentScore,
+    int CandidateScore,
+    IReadOnlyList<string> ScoreReasons,
+    bool Automatic);
+
+public sealed record LibraryIntegritySummary(
+    string TmdbId,
+    string AnimationName,
+    int Season,
+    int? ExpectedEpisodeCount,
+    IReadOnlyList<int> MissingEpisodes,
+    IReadOnlyList<EpisodeDuplicate> DuplicateEpisodes,
+    int UnidentifiedReleaseCount,
+    IReadOnlyList<ReleaseUpgradeCandidate> UpgradeCandidates);
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/ReleaseUpgrade.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/ReleaseUpgrade.cs
new file mode 100644
index 0000000..e6edb02
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/ReleaseUpgrade.cs
@@ -0,0 +1,183 @@
+namespace SecondDimensionWatcherReDive.Framework.DataRepository;
+
+public enum ReleaseUpgradeStatus
+{
+    Downloading,
+    Verifying,
+    Applied,
+    Failed,
+    RolledBack,
+    Completed
+}
+
+public enum ReleaseUpgradeMappingKind
+{
+    Previous,
+    Candidate
+}
+
+public enum ReleaseUpgradeDownloadSubmissionMarkOutcome
+{
+    Submitted,
+    AlreadySubmitted,
+    Settled,
+    LeaseLost,
+    StateChanged,
+    NotFound
+}
+
+public sealed record ReleaseUpgradeDownloadSubmissionLease(
+    Guid Id,
+    DateTimeOffset ExpiresAt,
+    bool IsPrepared);
+
+public sealed record ReleaseUpgradePendingDownloadCancellation(
+    Guid OperationId,
+    Guid CandidateReleaseId,
+    Guid SubmissionLeaseId,
+    bool RemoveFile);
+
+public sealed record ReleaseUpgradeOperation(
+    Guid Id,
+    Guid CurrentReleaseId,
+    Guid CandidateReleaseId,
+    ReleaseUpgradeStatus Status,
+    int CurrentScore,
+    int CandidateScore,
+    DateTimeOffset CreatedAt,
+    DateTimeOffset? VerifiedAt,
+    DateTimeOffset? AppliedAt,
+    DateTimeOffset? RollbackUntil,
+    DateTimeOffset? CompletedAt,
+    string? FailureSummary,
+    DateTimeOffset? DownloadPreparedAt = null,
+    DateTimeOffset? DownloadSubmittedAt = null,
+    Guid? DownloadSubmissionLeaseId = null,
+    DateTimeOffset? DownloadSubmissionLeaseUntil = null,
+    bool DownloadCancellationRemoveFile = false);
+
+public sealed record ReleaseUpgradeMappingSnapshot(
+    Guid Id,
+    Guid OperationId,
+    ReleaseUpgradeMappingKind Kind,
+    Guid OriginalMappingId,
+    Guid AnimationInfoId,
+    string VirtualPath,
+    string PhysicalPath,
+    string FileStore);
+
+public sealed record ReleaseUpgradeActivation(
+    ReleaseUpgradeOperation Operation,
+    IReadOnlyList<FileMapping> PreviousMappings,
+    IReadOnlyList<FileMapping> CandidateMappings);
+
+public sealed record ReleaseUpgradeMutationResult(
+    bool IsSuccess,
+    string Outcome,
+    ReleaseUpgradeOperation? Operation);
+
+public interface IReleaseUpgradeRepository
+{
+    Task<IReadOnlyList<ReleaseUpgradeCandidate>> GetCandidatesAsync(
+        bool automaticOnly,
+        int take,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeCandidate?> FindCandidateAsync(
+        Guid currentReleaseId,
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeOperation?> TryBeginAsync(
+        ReleaseUpgradeCandidate candidate,
+        DateTimeOffset createdAt,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeOperation?> FindByIdAsync(
+        Guid id,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeOperation?> FindActiveByCandidateAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<Guid>> GetReadyCandidateIdsAsync(
+        int take,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeDownloadSubmissionLease?> TryClaimDownloadSubmissionAsync(
+        Guid operationId,
+        Guid leaseId,
+        TimeSpan leaseDuration,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeDownloadSubmissionMarkOutcome> TryMarkDownloadSubmittedAsync(
+        Guid operationId,
+        Guid leaseId,
+        Guid? downloadAttemptId,
+        DateTimeOffset submittedAt,
+        CancellationToken cancellationToken);
+
+    Task<bool> TryMarkDownloadPreparedAsync(
+        Guid operationId,
+        Guid leaseId,
+        DateTimeOffset preparedAt,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<ReleaseUpgradePendingDownloadCancellation>>
+        GetPendingDownloadCancellationsAsync(
+            int take,
+            CancellationToken cancellationToken);
+
+    Task<int> ClearExpiredDownloadSubmissionLeasesWithoutCancellationAsync(
+        CancellationToken cancellationToken);
+
+    Task<bool> TryDeferDownloadCancellationAsync(
+        Guid operationId,
+        Guid submissionLeaseId,
+        TimeSpan retryDelay,
+        CancellationToken cancellationToken);
+
+    Task<bool> TryMarkDownloadCancellationReconciledAsync(
+        Guid operationId,
+        Guid submissionLeaseId,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeActivation?> GetActivationAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<FileMapping>> GetCandidateMappingsAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeActivation?> GetRollbackAsync(
+        Guid operationId,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeMutationResult> ActivateAsync(
+        Guid operationId,
+        IReadOnlyList<FileMapping> expectedPreviousMappings,
+        IReadOnlyList<FileMapping> expectedCandidateMappings,
+        DateTimeOffset verifiedAt,
+        DateTimeOffset rollbackUntil,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeMutationResult> MarkFailedAsync(
+        Guid operationId,
+        string failureSummary,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeMutationResult> RollbackAsync(
+        Guid operationId,
+        DateTimeOffset rolledBackAt,
+        CancellationToken cancellationToken);
+
+    Task<IReadOnlyList<ReleaseUpgradeOperation>> GetHistoryAsync(
+        int take,
+        CancellationToken cancellationToken);
+
+    Task<int> CompleteExpiredAsync(
+        DateTimeOffset completedAt,
+        CancellationToken cancellationToken);
+}
diff --git a/SecondDimensionWatcherReDive.Framework/DataRepository/SubscriptionAutomationPolicy.cs b/SecondDimensionWatcherReDive.Framework/DataRepository/SubscriptionAutomationPolicy.cs
index 11fec01..df78f8c 100644
--- a/SecondDimensionWatcherReDive.Framework/DataRepository/SubscriptionAutomationPolicy.cs
+++ b/SecondDimensionWatcherReDive.Framework/DataRepository/SubscriptionAutomationPolicy.cs
@@ -15,4 +15,7 @@ public sealed record SubscriptionAutomationPolicy(
     IReadOnlyList<string> ExcludedKeywords,
     SubscriptionAutomationMode Mode,
     DateTimeOffset CreatedAt,
-    DateTimeOffset UpdatedAt);
+    DateTimeOffset UpdatedAt,
+    bool EnableVersionUpgrade = false,
+    int MinimumUpgradeScore = 25,
+    int UpgradeRollbackHours = 72);
diff --git a/SecondDimensionWatcherReDive.Framework/Feed/AnimationAddRequest.cs b/SecondDimensionWatcherReDive.Framework/Feed/AnimationAddRequest.cs
index 294951c..ace7c0f 100644
--- a/SecondDimensionWatcherReDive.Framework/Feed/AnimationAddRequest.cs
+++ b/SecondDimensionWatcherReDive.Framework/Feed/AnimationAddRequest.cs
@@ -8,4 +8,6 @@ public record AnimationAddRequest(
     string DownloadType,
     string AdditionalDownloadInfo,
     Guid? FeedId = null,
-    long? ContentLength = null);
+    long? ContentLength = null,
+    string? FeedItemGuid = null,
+    string? EnclosureId = null);
diff --git a/SecondDimensionWatcherReDive.Framework/Feed/IReleaseScoringService.cs b/SecondDimensionWatcherReDive.Framework/Feed/IReleaseScoringService.cs
new file mode 100644
index 0000000..07780bb
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/Feed/IReleaseScoringService.cs
@@ -0,0 +1,12 @@
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+
+namespace SecondDimensionWatcherReDive.Framework.Feed;
+
+public sealed record ReleaseScore(int Value, IReadOnlyList<string> Reasons);
+
+public interface IReleaseScoringService
+{
+    ReleaseScore Score(
+        SubscriptionReleaseMetadata metadata,
+        SubscriptionAutomationPolicy? policy);
+}
diff --git a/SecondDimensionWatcherReDive.Framework/Feed/ReleaseIdentity.cs b/SecondDimensionWatcherReDive.Framework/Feed/ReleaseIdentity.cs
new file mode 100644
index 0000000..531da20
--- /dev/null
+++ b/SecondDimensionWatcherReDive.Framework/Feed/ReleaseIdentity.cs
@@ -0,0 +1,31 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace SecondDimensionWatcherReDive.Framework.Feed;
+
+public static class ReleaseIdentity
+{
+    public static string Create(
+        Guid? feedId,
+        string? feedItemGuid,
+        string? enclosureId,
+        string? torrentInfoHash,
+        string downloadUrl)
+    {
+        if (!string.IsNullOrWhiteSpace(torrentInfoHash))
+            return $"torrent:{torrentInfoHash.Trim().ToLowerInvariant()}";
+
+        var source = !string.IsNullOrWhiteSpace(feedItemGuid)
+            ? $"feed:{feedId?.ToString("N") ?? "static"}:{feedItemGuid.Trim()}"
+            : !string.IsNullOrWhiteSpace(enclosureId)
+                ? $"enclosure:{feedId?.ToString("N") ?? "static"}:{enclosureId.Trim()}"
+                : $"url:{downloadUrl.Trim()}";
+        return $"external:{Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(source))).ToLowerInvariant()}";
+    }
+
+    public static string CreateMediaImport(Guid sourceId, string fileStore, string storePath)
+    {
+        var source = $"{sourceId:N}\n{fileStore}\n{storePath}";
+        return $"import:{Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(source))).ToLowerInvariant()}";
+    }
+}
diff --git a/SecondDimensionWatcherReDive.Framework/FileDownload/IFileDownloadClient.cs b/SecondDimensionWatcherReDive.Framework/FileDownload/IFileDownloadClient.cs
index 3d9364f..747ab33 100644
--- a/SecondDimensionWatcherReDive.Framework/FileDownload/IFileDownloadClient.cs
+++ b/SecondDimensionWatcherReDive.Framework/FileDownload/IFileDownloadClient.cs
@@ -1,5 +1,12 @@
 namespace SecondDimensionWatcherReDive.Framework.FileDownload;
 
+public enum DownloadTaskReconciliationOutcome
+{
+    Confirmed,
+    Rejected,
+    Unknown
+}
+
 /// <summary>
 ///     Provides a contract for performing various file download operations.
 /// </summary>
@@ -27,10 +34,7 @@ public interface IFileDownloadClient
     /// <param name="downloadUrl">URL from which to download the item.</param>
     /// <param name="cachedDownloadData">Cache data for the download.</param>
     /// <param name="additionalDownloadInfo">Additional information for the download.</param>
-    /// <returns>
-    ///     A task that represents the asynchronous operation. The task result contains a boolean that indicates if the
-    ///     download task was submitted successfully.
-    /// </returns>
+    /// <returns>Whether the download client accepted the task.</returns>
     public Task<bool> SubmitDownloadTaskAsync(
         Guid itemId,
         string downloadUrl,
@@ -38,6 +42,18 @@ public Task<bool> SubmitDownloadTaskAsync(
         string additionalDownloadInfo,
         CancellationToken cancellationToken);
 
+    /// <summary>
+    ///     Ensures a previously persisted download submission exists remotely.
+    ///     Implementations must make this operation idempotent for the same item.
+    /// </summary>
+    /// <returns>The confirmed, rejected, or still-uncertain reconciliation outcome.</returns>
+    public Task<DownloadTaskReconciliationOutcome> EnsureDownloadTaskAsync(
+        Guid itemId,
+        string downloadUrl,
+        byte[] cachedDownloadData,
+        string additionalDownloadInfo,
+        CancellationToken cancellationToken);
+
     /// <summary>
     ///     Submits a query to check the progress of a download.
     /// </summary>
@@ -108,4 +124,4 @@ public Task<CancelDownloadResult> CancelDownloadTaskAsync(
         string additionalDownloadInfo,
         bool removeFile,
         CancellationToken cancellationToken);
-}
\ No newline at end of file
+}
diff --git a/SecondDimensionWatcherReDive.IntegrationTest/Helpers/Fakes.cs b/SecondDimensionWatcherReDive.IntegrationTest/Helpers/Fakes.cs
index 8bdeda7..d76fcee 100644
--- a/SecondDimensionWatcherReDive.IntegrationTest/Helpers/Fakes.cs
+++ b/SecondDimensionWatcherReDive.IntegrationTest/Helpers/Fakes.cs
@@ -104,6 +104,8 @@ public Task<bool> TryFinalizeDownloadCancellationAsync(
         Guid animationInfoId,
         Guid? downloadAttemptId,
         Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        SubscriptionAutomationDisposition? terminalDisposition,
         CancellationToken cancellationToken)
     {
         _mappings.RemoveAll(mapping => mapping.AnimationInfoId == animationInfoId);
diff --git a/SecondDimensionWatcherReDive.Test/AnimationInfoControllerTests.cs b/SecondDimensionWatcherReDive.Test/AnimationInfoControllerTests.cs
index 1cf8e25..cca52e1 100644
--- a/SecondDimensionWatcherReDive.Test/AnimationInfoControllerTests.cs
+++ b/SecondDimensionWatcherReDive.Test/AnimationInfoControllerTests.cs
@@ -33,6 +33,12 @@ public void Setup()
         _providerMock
             .Setup(p => p.GetRequiredClient(It.IsAny<string>()))
             .Returns(_downloadClientMock.Object);
+        _repoMock.Setup(repository => repository.TryMarkDownloadSubmittedAsync(
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
         _controller = new AnimationInfoController(
             _repoMock.Object,
@@ -113,10 +119,14 @@ public async Task StartDownload_Success_ReturnsOkAndUpdatesEntity()
             .Setup(r => r.TryStartDownloadAsync(
                 id,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 null,
                 CancellationToken.None))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
 
         _downloadClientMock
             .Setup(c => c.SubmitDownloadTaskAsync(
@@ -124,7 +134,7 @@ public async Task StartDownload_Success_ReturnsOkAndUpdatesEntity()
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(true);
 
         var result = await _controller.StartDownload(id, CancellationToken.None);
@@ -133,6 +143,8 @@ public async Task StartDownload_Success_ReturnsOkAndUpdatesEntity()
         _repoMock.Verify(r => r.TryStartDownloadAsync(
             id,
             It.Is<Guid>(attempt => attempt != Guid.Empty),
+            It.IsAny<Guid>(),
+            It.IsAny<TimeSpan>(),
             It.IsAny<DateTimeOffset>(),
             null,
             CancellationToken.None), Times.Once);
@@ -153,17 +165,21 @@ public async Task StartDownload_PendingConfirmation_MarksManualDownloadQueued()
             .Setup(r => r.TryStartDownloadAsync(
                 id,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 null,
                 CancellationToken.None))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
         _downloadClientMock
             .Setup(c => c.SubmitDownloadTaskAsync(
                 id,
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(true);
 
         var result = await _controller.StartDownload(id, CancellationToken.None);
@@ -172,6 +188,8 @@ public async Task StartDownload_PendingConfirmation_MarksManualDownloadQueued()
         _repoMock.Verify(r => r.TryStartDownloadAsync(
             id,
             It.IsAny<Guid>(),
+            It.IsAny<Guid>(),
+            It.IsAny<TimeSpan>(),
             It.IsAny<DateTimeOffset>(),
             null,
             CancellationToken.None), Times.Once);
@@ -183,42 +201,58 @@ public async Task StartDownload_ClientRejects_ReleasesReservedAttempt()
         var id = Guid.NewGuid();
         var info = CreateTestInfo(id);
         Guid? reservedAttempt = null;
+        var cancellationLeaseId = Guid.NewGuid();
         _repoMock.Setup(repository => repository.FindByIdAsync(id, CancellationToken.None))
             .ReturnsAsync(info);
         _repoMock.Setup(repository => repository.TryStartDownloadAsync(
                 id,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 null,
                 CancellationToken.None))
-            .Callback<Guid, Guid, DateTimeOffset, SubscriptionAutomationDisposition?, CancellationToken>(
-                (_, attempt, _, _, _) => reservedAttempt = attempt)
-            .ReturnsAsync(true);
+            .Callback<Guid, Guid, Guid, TimeSpan, DateTimeOffset,
+                SubscriptionAutomationDisposition?, CancellationToken>(
+                (_, attempt, _, _, _, _, _) => reservedAttempt = attempt)
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
         _downloadClientMock.Setup(client => client.SubmitDownloadTaskAsync(
                 id,
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(false);
-        _repoMock.Setup(repository => repository.TryCancelDownloadAsync(
+        _repoMock.Setup(repository => repository.TryBeginCancelDownloadAsync(
                 id,
                 It.IsAny<Guid?>(),
-                null,
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.Is<CancellationToken>(token =>
                     token.CanBeCanceled && !token.IsCancellationRequested)))
-            .ReturnsAsync(info with { IsDownloadTracked = false });
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
+        _fileMappingRepoMock.Setup(repository => repository.TryFinalizeDownloadCancellationAsync(
+                id,
+                It.IsAny<Guid?>(),
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
         var result = await _controller.StartDownload(id, CancellationToken.None);
 
         Assert.IsInstanceOfType<BadRequestResult>(result);
         Assert.IsNotNull(reservedAttempt);
-        _repoMock.Verify(repository => repository.TryCancelDownloadAsync(
-            id,
-            reservedAttempt,
-            null,
-            It.Is<CancellationToken>(token =>
-                token.CanBeCanceled && !token.IsCancellationRequested)), Times.Once);
     }
 
     [TestMethod]
@@ -226,32 +260,45 @@ public async Task StartDownload_ReservationCancellation_UsesIndependentCleanupTo
     {
         var id = Guid.NewGuid();
         var info = CreateTestInfo(id);
+        var cancellationLeaseId = Guid.NewGuid();
         _repoMock.Setup(repository => repository.FindByIdAsync(id, CancellationToken.None))
             .ReturnsAsync(info);
         _repoMock.Setup(repository => repository.TryStartDownloadAsync(
                 id,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 null,
                 CancellationToken.None))
             .ThrowsAsync(new OperationCanceledException());
-        _repoMock.Setup(repository => repository.TryCancelDownloadAsync(
+        _repoMock.Setup(repository => repository.TryBeginCancelDownloadAsync(
                 id,
                 It.IsAny<Guid?>(),
-                null,
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.Is<CancellationToken>(token =>
                     token.CanBeCanceled && !token.IsCancellationRequested)))
-            .ReturnsAsync(info with { IsDownloadTracked = false });
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
+        _fileMappingRepoMock.Setup(repository => repository.TryFinalizeDownloadCancellationAsync(
+                id,
+                It.IsAny<Guid?>(),
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
         await Assert.ThrowsExactlyAsync<OperationCanceledException>(() =>
             _controller.StartDownload(id, CancellationToken.None));
 
-        _repoMock.Verify(repository => repository.TryCancelDownloadAsync(
-            id,
-            It.IsAny<Guid?>(),
-            null,
-            It.Is<CancellationToken>(token =>
-                token.CanBeCanceled && !token.IsCancellationRequested)), Times.Once);
         _downloadClientMock.Verify(client => client.SubmitDownloadTaskAsync(
             It.IsAny<Guid>(),
             It.IsAny<string>(),
@@ -272,16 +319,20 @@ public async Task StartDownload_IdentifiedItem_PreservesAnimationAndGroup()
         _repoMock.Setup(repository => repository.TryStartDownloadAsync(
                 id,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 null,
                 CancellationToken.None))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
         _downloadClientMock.Setup(client => client.SubmitDownloadTaskAsync(
                 id,
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(true);
 
         var result = await _controller.StartDownload(id, CancellationToken.None);
@@ -298,6 +349,7 @@ public async Task CancelDownload_Success_SetsIsDownloadTrackedFalseAndUpdates()
         var id = Guid.NewGuid();
         var info = CreateTestInfo(id, isDownloadTracked: true);
         Guid? cancellationAttemptId = null;
+        var cancellationLeaseId = Guid.NewGuid();
 
         _repoMock
             .Setup(r => r.FindByIdAsync(id, CancellationToken.None))
@@ -310,23 +362,34 @@ public async Task CancelDownload_Success_SetsIsDownloadTrackedFalseAndUpdates()
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
                 false,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(new CancelDownloadResult(true, false));
         _repoMock
             .Setup(r => r.TryBeginCancelDownloadAsync(
                 id,
                 info.DownloadAttemptId,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.Is<CancellationToken>(token =>
                     token.CanBeCanceled && !token.IsCancellationRequested)))
-            .Callback<Guid, Guid?, Guid, CancellationToken>(
-                (_, _, cancellationId, _) => cancellationAttemptId = cancellationId)
-            .ReturnsAsync(true);
+            .Callback<Guid, Guid?, Guid, Guid, TimeSpan, bool, bool,
+                SubscriptionAutomationDisposition?, CancellationToken>(
+                (_, _, cancellationId, _, _, _, _, _, _) => cancellationAttemptId = cancellationId)
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
         _fileMappingRepoMock
             .Setup(r => r.TryFinalizeDownloadCancellationAsync(
                 id,
                 info.DownloadAttemptId,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.Is<CancellationToken>(token =>
                     token.CanBeCanceled && !token.IsCancellationRequested)))
             .ReturnsAsync(true);
@@ -339,6 +402,8 @@ public async Task CancelDownload_Success_SetsIsDownloadTrackedFalseAndUpdates()
             id,
             info.DownloadAttemptId,
             cancellationAttemptId.Value,
+            It.IsAny<Guid>(),
+            It.IsAny<SubscriptionAutomationDisposition?>(),
             It.Is<CancellationToken>(token =>
                 token.CanBeCanceled && !token.IsCancellationRequested)), Times.Once);
     }
@@ -347,6 +412,7 @@ public async Task CancelDownload_Success_SetsIsDownloadTrackedFalseAndUpdates()
     public async Task CancelDownload_AutomaticDownload_MarksDispositionCancelled()
     {
         var id = Guid.NewGuid();
+        var cancellationLeaseId = Guid.NewGuid();
         var info = CreateTestInfo(
             id,
             isDownloadTracked: true,
@@ -358,18 +424,28 @@ public async Task CancelDownload_AutomaticDownload_MarksDispositionCancelled()
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
                 false,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(new CancelDownloadResult(true, false));
         _repoMock.Setup(r => r.TryBeginCancelDownloadAsync(
                 id,
                 info.DownloadAttemptId,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.IsAny<CancellationToken>()))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
         _fileMappingRepoMock.Setup(r => r.TryFinalizeDownloadCancellationAsync(
                 id,
                 info.DownloadAttemptId,
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.IsAny<CancellationToken>()))
             .ReturnsAsync(true);
 
@@ -380,6 +456,8 @@ public async Task CancelDownload_AutomaticDownload_MarksDispositionCancelled()
             id,
             info.DownloadAttemptId,
             It.IsAny<Guid>(),
+            It.IsAny<Guid>(),
+            It.IsAny<SubscriptionAutomationDisposition?>(),
             It.IsAny<CancellationToken>()), Times.Once);
     }
 
@@ -388,6 +466,7 @@ public async Task CancelDownload_PendingCancellation_ReusesIdAndFinalizes()
     {
         var id = Guid.NewGuid();
         var cancellationAttemptId = Guid.NewGuid();
+        var cancellationLeaseId = Guid.NewGuid();
         var info = CreateTestInfo(id, isDownloadTracked: true) with
         {
             DownloadAttemptId = Guid.NewGuid(),
@@ -399,20 +478,30 @@ public async Task CancelDownload_PendingCancellation_ReusesIdAndFinalizes()
                 id,
                 info.DownloadAttemptId,
                 cancellationAttemptId,
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.IsAny<CancellationToken>()))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
         _downloadClientMock.Setup(client => client.CancelDownloadTaskAsync(
                 id,
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
                 false,
-                CancellationToken.None))
+                It.IsAny<CancellationToken>()))
             .ReturnsAsync(new CancelDownloadResult(true, false));
         _fileMappingRepoMock.Setup(repository => repository.TryFinalizeDownloadCancellationAsync(
                 id,
                 info.DownloadAttemptId,
                 cancellationAttemptId,
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.IsAny<CancellationToken>()))
             .ReturnsAsync(true);
 
@@ -423,11 +512,18 @@ public async Task CancelDownload_PendingCancellation_ReusesIdAndFinalizes()
             id,
             info.DownloadAttemptId,
             cancellationAttemptId,
+            It.IsAny<Guid>(),
+            It.IsAny<TimeSpan>(),
+            It.IsAny<bool>(),
+            It.IsAny<bool>(),
+            It.IsAny<SubscriptionAutomationDisposition?>(),
             It.IsAny<CancellationToken>()), Times.Once);
         _fileMappingRepoMock.Verify(repository => repository.TryFinalizeDownloadCancellationAsync(
             id,
             info.DownloadAttemptId,
             cancellationAttemptId,
+            It.IsAny<Guid>(),
+            It.IsAny<SubscriptionAutomationDisposition?>(),
             It.IsAny<CancellationToken>()), Times.Once);
     }
 
diff --git a/SecondDimensionWatcherReDive.Test/SyncFeedTests.cs b/SecondDimensionWatcherReDive.Test/SyncFeedTests.cs
index 6c77894..2776d5c 100644
--- a/SecondDimensionWatcherReDive.Test/SyncFeedTests.cs
+++ b/SecondDimensionWatcherReDive.Test/SyncFeedTests.cs
@@ -18,6 +18,7 @@ public class SyncFeedTests
 {
     private Mock<IAnimationInfoRepository> _mockRepo = null!;
     private Mock<ISubscriptionAutomationPolicyRepository> _mockPolicyRepo = null!;
+    private Mock<IFileMappingRepository> _mockFileMappingRepo = null!;
     private Mock<IFileDownloadClientProvider> _mockDownloadProvider = null!;
     private Mock<IFileDownloadClient> _mockDownloadClient = null!;
     private SyncFeed _syncFeed = null!;
@@ -28,6 +29,7 @@ public void Setup()
     {
         _mockRepo = new Mock<IAnimationInfoRepository>();
         _mockPolicyRepo = new Mock<ISubscriptionAutomationPolicyRepository>();
+        _mockFileMappingRepo = new Mock<IFileMappingRepository>();
         _mockDownloadProvider = new Mock<IFileDownloadClientProvider>();
         _mockDownloadClient = new Mock<IFileDownloadClient>();
         _mockRepo.Setup(repository => repository.AddAsync(
@@ -36,6 +38,12 @@ public void Setup()
         _mockRepo.Setup(repository => repository.UpdateAsync(
                 It.IsAny<AnimationInfo>(), It.IsAny<CancellationToken>()))
             .Returns(Task.CompletedTask);
+        _mockRepo.Setup(repository => repository.TryMarkDownloadSubmittedAsync(
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
         var mockScope = new Mock<IServiceScope>();
         var mockScopeFactory = new Mock<IServiceScopeFactory>();
@@ -52,6 +60,9 @@ public void Setup()
         mockScopeServiceProvider
             .Setup(provider => provider.GetService(typeof(IFileDownloadClientProvider)))
             .Returns(_mockDownloadProvider.Object);
+        mockScopeServiceProvider
+            .Setup(provider => provider.GetService(typeof(IFileMappingRepository)))
+            .Returns(_mockFileMappingRepo.Object);
 
         var mockServiceProvider = new Mock<IServiceProvider>();
         var outboundFetcher = new Mock<ISafeOutboundHttpFetcher>();
@@ -207,16 +218,22 @@ public async Task ProcessSingle_AutoDownload_SubmitsAndMarksQueued()
         _mockRepo.Setup(repository => repository.TryStartDownloadAsync(
                 It.IsAny<Guid>(),
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 SubscriptionAutomationDisposition.AutoDownloadQueued,
                 It.IsAny<CancellationToken>()))
-            .ReturnsAsync(true);
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
 
         await InvokeProcessSingleAsync(request);
 
         _mockRepo.Verify(repository => repository.TryStartDownloadAsync(
             It.IsAny<Guid>(),
             It.Is<Guid>(attempt => attempt != Guid.Empty),
+            It.IsAny<Guid>(),
+            It.IsAny<TimeSpan>(),
             It.IsAny<DateTimeOffset>(),
             SubscriptionAutomationDisposition.AutoDownloadQueued,
             It.IsAny<CancellationToken>()), Times.Once);
@@ -226,6 +243,7 @@ public async Task ProcessSingle_AutoDownload_SubmitsAndMarksQueued()
     public async Task ProcessSingle_AutoDownloadRejected_MarksFailed()
     {
         var feedId = Guid.NewGuid();
+        var cancellationLeaseId = Guid.NewGuid();
         var request = PolicyRequest(feedId, "[Group] Anime [1080p HEVC][CHS]");
         SetupNewPolicyRequest(request, Policy(feedId, SubscriptionAutomationMode.AutoDownload));
         _mockDownloadProvider.Setup(provider => provider.GetRequiredClient(request.DownloadType))
@@ -237,25 +255,38 @@ public async Task ProcessSingle_AutoDownloadRejected_MarksFailed()
         _mockRepo.Setup(repository => repository.TryStartDownloadAsync(
                 It.IsAny<Guid>(),
                 It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
                 It.IsAny<DateTimeOffset>(),
                 SubscriptionAutomationDisposition.AutoDownloadQueued,
                 It.IsAny<CancellationToken>()))
-            .ReturnsAsync(true);
-        _mockRepo.Setup(repository => repository.TryCancelDownloadAsync(
+            .ReturnsAsync(new DownloadSubmissionLease(
+                Guid.NewGuid(),
+                DateTimeOffset.UtcNow.AddMinutes(3)));
+        _mockRepo.Setup(repository => repository.TryBeginCancelDownloadAsync(
                 It.IsAny<Guid>(),
                 It.IsAny<Guid?>(),
-                SubscriptionAutomationDisposition.AutoDownloadFailed,
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<TimeSpan>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
                 It.IsAny<CancellationToken>()))
-            .ReturnsAsync((AnimationInfo?)null);
+            .ReturnsAsync(new DownloadCancellationLease(
+                cancellationLeaseId,
+                DateTimeOffset.UtcNow.AddMinutes(3),
+                false));
+        _mockFileMappingRepo.Setup(repository => repository.TryFinalizeDownloadCancellationAsync(
+                It.IsAny<Guid>(),
+                It.IsAny<Guid?>(),
+                It.IsAny<Guid>(),
+                It.IsAny<Guid>(),
+                It.IsAny<SubscriptionAutomationDisposition?>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(true);
 
         await InvokeProcessSingleAsync(request);
-
-        _mockRepo.Verify(repository => repository.TryCancelDownloadAsync(
-            It.IsAny<Guid>(),
-            It.IsAny<Guid?>(),
-            SubscriptionAutomationDisposition.AutoDownloadFailed,
-            It.Is<CancellationToken>(token =>
-                token.CanBeCanceled && !token.IsCancellationRequested)), Times.Once);
     }
 
     [TestMethod]
diff --git a/SecondDimensionWatcherReDive/Controllers/AnimationInfoController.cs b/SecondDimensionWatcherReDive/Controllers/AnimationInfoController.cs
index 5bf282d..2139008 100644
--- a/SecondDimensionWatcherReDive/Controllers/AnimationInfoController.cs
+++ b/SecondDimensionWatcherReDive/Controllers/AnimationInfoController.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Text.Json;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Authorization;
@@ -24,6 +25,12 @@ internal class AnimationInfoController(
     INotificationPublisher? notificationPublisher = null)
     : ControllerBase
 {
+    private static readonly TimeSpan DownloadSubmissionLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadSubmissionRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadCancellationLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadCancellationRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadLeaseSafetyMargin = TimeSpan.FromSeconds(1);
+
     [HttpGet]
     public async Task<IActionResult> GetAsync(
         [FromQuery] int skip = 0,
@@ -182,33 +189,72 @@ public async Task<IActionResult> StartDownload([FromRoute] Guid id, Cancellation
 
         var downloadClient = fileDownloadClientProvider.GetRequiredClient(info.DownloadType);
         var downloadAttemptId = Guid.NewGuid();
+        var submissionLeaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
         var submissionAttempted = false;
         try
         {
-            if (!await animationInfoRepository.TryStartDownloadAsync(
+            var submissionLease = await animationInfoRepository.TryStartDownloadAsync(
                     id,
                     downloadAttemptId,
+                    submissionLeaseId,
+                    DownloadSubmissionLeaseDuration,
                     DateTimeOffset.Now,
                     queuedDisposition: null,
-                    cancellationToken))
+                    cancellationToken);
+            if (submissionLease is null)
                 return Conflict();
 
+            var remainingRemoteBudget = DownloadSubmissionRemoteBudget -
+                                        Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+            if (remainingRemoteBudget <= TimeSpan.Zero)
+            {
+                await CompensateFailedStartAsync(
+                    info,
+                    downloadClient,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: false);
+                return StatusCode(StatusCodes.Status503ServiceUnavailable);
+            }
+
+            using var submissionCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+                cancellationToken);
+            submissionCancellation.CancelAfter(remainingRemoteBudget);
+            submissionCancellation.Token.ThrowIfCancellationRequested();
             submissionAttempted = true;
             if (!await downloadClient.SubmitDownloadTaskAsync(
                 id,
                 info.DownloadUrl,
                 info.CachedDownloadData,
                 info.AdditionalDownloadInfo,
-                cancellationToken))
+                submissionCancellation.Token))
             {
                 await CompensateFailedStartAsync(
                     info,
                     downloadClient,
                     downloadAttemptId,
+                    submissionLeaseId,
                     remoteMayHaveAccepted: false);
                 await PublishDownloadFailureAsync(info, downloadAttemptId, cancellationToken);
                 return BadRequest();
             }
+
+            using var markCancellation = CreateDownloadSagaTokenSource();
+            if (!await animationInfoRepository.TryMarkDownloadSubmittedAsync(
+                    id,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    markCancellation.Token))
+            {
+                await CompensateFailedStartAsync(
+                    info,
+                    downloadClient,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: true);
+                return Conflict();
+            }
         }
         catch
         {
@@ -218,6 +264,7 @@ await CompensateFailedStartAsync(
                     info,
                     downloadClient,
                     downloadAttemptId,
+                    submissionLeaseId,
                     submissionAttempted);
             }
             catch
@@ -323,24 +370,40 @@ public async Task<IActionResult> CancelDownload([FromRoute] Guid id, [FromQuery]
         // remote delete but did not observe the local finalize commit. Reuse it
         // so cancellation can be resumed idempotently across requests.
         var cancellationAttemptId = info.DownloadCancellationId ?? Guid.NewGuid();
+        var cancellationLeaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
+        DownloadCancellationLease? cancellationLease;
         cancellationToken.ThrowIfCancellationRequested();
         using (var beginCancellation = CreateDownloadSagaTokenSource())
         {
-            if (!await animationInfoRepository.TryBeginCancelDownloadAsync(
+            cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
                     id,
                     info.DownloadAttemptId,
                     cancellationAttemptId,
-                    beginCancellation.Token))
+                    cancellationLeaseId,
+                    DownloadCancellationLeaseDuration,
+                    removeFile,
+                    requireUnfinished: false,
+                    SubscriptionAutomationDisposition.DownloadCancelled,
+                    beginCancellation.Token);
+            if (cancellationLease is null)
                 return Conflict();
         }
 
+        var remainingRemoteBudget = DownloadCancellationRemoteBudget -
+                                    Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+        if (remainingRemoteBudget <= TimeSpan.Zero)
+            return Conflict();
+        using var remoteCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        remoteCancellation.CancelAfter(remainingRemoteBudget);
+        remoteCancellation.Token.ThrowIfCancellationRequested();
         var result = await downloadClient.CancelDownloadTaskAsync(
             id,
             info.DownloadUrl,
             info.CachedDownloadData,
             info.AdditionalDownloadInfo,
-            removeFile,
-            cancellationToken);
+            cancellationLease.RemoveFile,
+            remoteCancellation.Token);
 
         if (!result.IsSuccess)
         {
@@ -349,11 +412,17 @@ public async Task<IActionResult> CancelDownload([FromRoute] Guid id, [FromQuery]
             return StatusCode(StatusCodes.Status500InternalServerError);
         }
 
-        using var finalizeCancellation = CreateDownloadSagaTokenSource();
+        using var finalizeCancellation = CreateLeaseBoundSagaTokenSource(
+            leaseRequestStartedAt,
+            DownloadCancellationLeaseDuration);
+        if (finalizeCancellation is null)
+            return Conflict();
         var cancelled = await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
             id,
             info.DownloadAttemptId,
             cancellationAttemptId,
+            cancellationLease.Id,
+            SubscriptionAutomationDisposition.DownloadCancelled,
             finalizeCancellation.Token);
         if (!cancelled)
             return Conflict();
@@ -364,19 +433,38 @@ private async Task CompensateFailedStartAsync(
         AnimationInfo info,
         IFileDownloadClient downloadClient,
         Guid downloadAttemptId,
+        Guid submissionLeaseId,
         bool remoteMayHaveAccepted)
     {
         using var cleanup = CreateDownloadSagaTokenSource();
+        var cancellationAttemptId = Guid.NewGuid();
+        var cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+            info.Id,
+            downloadAttemptId,
+            cancellationAttemptId,
+            submissionLeaseId,
+            DownloadCancellationLeaseDuration,
+            removeFile: false,
+            requireUnfinished: true,
+            terminalDisposition: info.AutomationDisposition ==
+                SubscriptionAutomationDisposition.AutoDownloadFailed
+                    ? SubscriptionAutomationDisposition.AutoDownloadFailed
+                    : null,
+            cleanup.Token);
+        if (cancellationLease is null)
+            return;
+
         if (remoteMayHaveAccepted)
         {
             try
             {
+                cleanup.Token.ThrowIfCancellationRequested();
                 var remoteCancellation = await downloadClient.CancelDownloadTaskAsync(
                     info.Id,
                     info.DownloadUrl,
                     info.CachedDownloadData,
                     info.AdditionalDownloadInfo,
-                    removeFile: false,
+                    cancellationLease.RemoveFile,
                     cleanup.Token);
                 if (!remoteCancellation.IsSuccess)
                 {
@@ -391,9 +479,12 @@ private async Task CompensateFailedStartAsync(
             }
         }
 
-        await animationInfoRepository.TryCancelDownloadAsync(
+        cleanup.Token.ThrowIfCancellationRequested();
+        await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
             info.Id,
             downloadAttemptId,
+            cancellationAttemptId,
+            cancellationLease.Id,
             terminalDisposition: info.AutomationDisposition ==
                 SubscriptionAutomationDisposition.AutoDownloadFailed
                     ? SubscriptionAutomationDisposition.AutoDownloadFailed
@@ -424,6 +515,19 @@ await downloadClient.SubmitQueryDownloadProgressAsync(
     private static CancellationTokenSource CreateDownloadSagaTokenSource() =>
         new(TimeSpan.FromSeconds(10));
 
+    private static CancellationTokenSource? CreateLeaseBoundSagaTokenSource(
+        long leaseRequestStartedAt,
+        TimeSpan leaseDuration)
+    {
+        var remaining = leaseDuration -
+                        Stopwatch.GetElapsedTime(leaseRequestStartedAt) -
+                        DownloadLeaseSafetyMargin;
+        if (remaining <= TimeSpan.Zero)
+            return null;
+        return new CancellationTokenSource(
+            remaining < TimeSpan.FromSeconds(10) ? remaining : TimeSpan.FromSeconds(10));
+    }
+
     [HttpPost("{id:guid}/retry-inference")]
     public async Task<IActionResult> RetryInference([FromRoute] Guid id, CancellationToken cancellationToken)
     {
diff --git a/SecondDimensionWatcherReDive/Controllers/Converter.cs b/SecondDimensionWatcherReDive/Controllers/Converter.cs
index 5e1b146..03d13bc 100644
--- a/SecondDimensionWatcherReDive/Controllers/Converter.cs
+++ b/SecondDimensionWatcherReDive/Controllers/Converter.cs
@@ -84,7 +84,10 @@ public static External.SubscriptionAutomationPolicy ToExternal(
             record.ExcludedKeywords,
             record.Mode.ToString(),
             record.CreatedAt,
-            record.UpdatedAt);
+            record.UpdatedAt,
+            record.EnableVersionUpgrade,
+            record.MinimumUpgradeScore,
+            record.UpgradeRollbackHours);
 
     public static External.SubscriptionAutomationSimulationResult ToExternal(
         this Framework.Feed.SubscriptionAutomationSimulationResult result) =>
@@ -104,6 +107,85 @@ public static External.SubscriptionAutomationSimulationResult ToExternal(
                         explanation.Expected,
                         explanation.Message)).ToList())).ToList());
 
+    public static External.LibrarySearchItemResponse ToExternal(this LibrarySearchItem item) =>
+        new(item.AnimationInfoId,
+            item.Title,
+            item.AnimationName,
+            item.AnimationOriginalName,
+            item.TmdbId,
+            item.Season,
+            item.Episode,
+            item.SubtitleGroup,
+            item.Resolution,
+            item.Codec,
+            item.Languages,
+            item.IsDownloadTracked,
+            item.IsDownloadFinished,
+            item.IsMediaLibraryImport,
+            item.IsWatched,
+            item.PlaybackPositionSeconds,
+            item.VirtualPaths,
+            item.VirtualPathCount,
+            item.ReleaseScore,
+            item.ScoreReasons,
+            item.PublishedAt);
+
+    public static External.LibrarySearchResponse ToExternal(this LibrarySearchResult result) =>
+        new(result.Items.Select(item => item.ToExternal()).ToList(), result.NextCursor);
+
+    public static External.ReleaseUpgradeCandidateResponse ToExternal(
+        this ReleaseUpgradeCandidate candidate) =>
+        new(candidate.CurrentReleaseId,
+            candidate.CandidateReleaseId,
+            candidate.AnimationName,
+            candidate.Season,
+            candidate.Episode,
+            candidate.CurrentScore,
+            candidate.CandidateScore,
+            candidate.ScoreReasons,
+            candidate.Automatic);
+
+    public static External.LibraryIntegritySummaryResponse ToExternal(
+        this LibraryIntegritySummary summary) =>
+        new(summary.TmdbId,
+            summary.AnimationName,
+            summary.Season,
+            summary.ExpectedEpisodeCount,
+            summary.MissingEpisodes,
+            summary.DuplicateEpisodes.Select(duplicate => new External.EpisodeDuplicateResponse(
+                duplicate.Episode,
+                duplicate.ReleaseIds)).ToList(),
+            summary.UnidentifiedReleaseCount,
+            summary.UpgradeCandidates.Select(candidate => candidate.ToExternal()).ToList());
+
+    public static External.ReleaseUpgradeOperationResponse ToExternal(
+        this ReleaseUpgradeOperation operation) =>
+        new(operation.Id,
+            operation.CurrentReleaseId,
+            operation.CandidateReleaseId,
+            operation.Status.ToString(),
+            operation.CurrentScore,
+            operation.CandidateScore,
+            operation.CreatedAt,
+            operation.VerifiedAt,
+            operation.AppliedAt,
+            operation.RollbackUntil,
+            operation.CompletedAt,
+            operation.FailureSummary);
+
+    public static External.ReleaseUpgradeMutationResponse ToExternal(
+        this ReleaseUpgradeMutationResult result) =>
+        new(result.IsSuccess, result.Outcome, result.Operation?.ToExternal());
+
+    public static External.ReleaseUpgradeExecutionResponse ToExternal(
+        this Utils.ReleaseUpgrades.ReleaseUpgradeExecutionResult result) =>
+        new(result.IsSuccess,
+            result.Outcome,
+            result.DryRun,
+            result.RequiresDownload,
+            result.Operation?.ToExternal(),
+            result.ValidationErrors);
+
     public static External.WebDavTokenSummary ToExternal(this WebDavToken record) =>
         new(record.Id, record.Username, record.Description, record.CreatedAt);
 
diff --git a/SecondDimensionWatcherReDive/Controllers/External/AppJsonSerializerContext.cs b/SecondDimensionWatcherReDive/Controllers/External/AppJsonSerializerContext.cs
index d3c76f4..b9d5b50 100644
--- a/SecondDimensionWatcherReDive/Controllers/External/AppJsonSerializerContext.cs
+++ b/SecondDimensionWatcherReDive/Controllers/External/AppJsonSerializerContext.cs
@@ -69,6 +69,13 @@ namespace SecondDimensionWatcherReDive.Controllers.External;
 [JsonSerializable(typeof(QueueMediaLibraryScanResponse))]
 [JsonSerializable(typeof(ApplicationSettingsResponse))]
 [JsonSerializable(typeof(PatchApplicationSettingsRequest))]
+[JsonSerializable(typeof(ExecuteReleaseUpgradeRequest))]
+[JsonSerializable(typeof(LibrarySearchResponse))]
+[JsonSerializable(typeof(List<LibraryIntegritySummaryResponse>))]
+[JsonSerializable(typeof(List<ReleaseUpgradeCandidateResponse>))]
+[JsonSerializable(typeof(List<ReleaseUpgradeOperationResponse>))]
+[JsonSerializable(typeof(ReleaseUpgradeMutationResponse))]
+[JsonSerializable(typeof(ReleaseUpgradeExecutionResponse))]
 [JsonSerializable(typeof(NotificationDeliveryItem))]
 [JsonSerializable(typeof(List<NotificationDeliveryItem>))]
 [JsonSerializable(typeof(TestNotificationResponse))]
diff --git a/SecondDimensionWatcherReDive/Controllers/External/Library.cs b/SecondDimensionWatcherReDive/Controllers/External/Library.cs
new file mode 100644
index 0000000..39e01e5
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Controllers/External/Library.cs
@@ -0,0 +1,85 @@
+namespace SecondDimensionWatcherReDive.Controllers.External;
+
+internal sealed record ExecuteReleaseUpgradeRequest(
+    Guid CurrentReleaseId,
+    Guid CandidateReleaseId,
+    bool DryRun = true);
+
+internal sealed record LibrarySearchItemResponse(
+    Guid AnimationInfoId,
+    string Title,
+    string? AnimationName,
+    string? AnimationOriginalName,
+    string? TmdbId,
+    int? Season,
+    int? Episode,
+    string? SubtitleGroup,
+    string? Resolution,
+    string? Codec,
+    IReadOnlyList<string> Languages,
+    bool IsDownloadTracked,
+    bool IsDownloadFinished,
+    bool IsMediaLibraryImport,
+    bool IsWatched,
+    double? PlaybackPositionSeconds,
+    IReadOnlyList<string> VirtualPaths,
+    long VirtualPathCount,
+    int ReleaseScore,
+    IReadOnlyList<string> ScoreReasons,
+    DateTimeOffset PublishedAt);
+
+internal sealed record LibrarySearchResponse(
+    IReadOnlyList<LibrarySearchItemResponse> Items,
+    string? NextCursor);
+
+internal sealed record EpisodeDuplicateResponse(
+    int Episode,
+    IReadOnlyList<Guid> ReleaseIds);
+
+internal sealed record ReleaseUpgradeCandidateResponse(
+    Guid CurrentReleaseId,
+    Guid CandidateReleaseId,
+    string AnimationName,
+    int Season,
+    int Episode,
+    int CurrentScore,
+    int CandidateScore,
+    IReadOnlyList<string> ScoreReasons,
+    bool Automatic);
+
+internal sealed record LibraryIntegritySummaryResponse(
+    string TmdbId,
+    string AnimationName,
+    int Season,
+    int? ExpectedEpisodeCount,
+    IReadOnlyList<int> MissingEpisodes,
+    IReadOnlyList<EpisodeDuplicateResponse> DuplicateEpisodes,
+    int UnidentifiedReleaseCount,
+    IReadOnlyList<ReleaseUpgradeCandidateResponse> UpgradeCandidates);
+
+internal sealed record ReleaseUpgradeOperationResponse(
+    Guid Id,
+    Guid CurrentReleaseId,
+    Guid CandidateReleaseId,
+    string Status,
+    int CurrentScore,
+    int CandidateScore,
+    DateTimeOffset CreatedAt,
+    DateTimeOffset? VerifiedAt,
+    DateTimeOffset? AppliedAt,
+    DateTimeOffset? RollbackUntil,
+    DateTimeOffset? CompletedAt,
+    string? FailureSummary);
+
+internal sealed record ReleaseUpgradeMutationResponse(
+    bool IsSuccess,
+    string Outcome,
+    ReleaseUpgradeOperationResponse? Operation);
+
+internal sealed record ReleaseUpgradeExecutionResponse(
+    bool IsSuccess,
+    string Outcome,
+    bool DryRun,
+    bool RequiresDownload,
+    ReleaseUpgradeOperationResponse? Operation,
+    IReadOnlyList<string> ValidationErrors);
diff --git a/SecondDimensionWatcherReDive/Controllers/External/SubscriptionAutomationPolicy.cs b/SecondDimensionWatcherReDive/Controllers/External/SubscriptionAutomationPolicy.cs
index d27d33a..2bc1fa9 100644
--- a/SecondDimensionWatcherReDive/Controllers/External/SubscriptionAutomationPolicy.cs
+++ b/SecondDimensionWatcherReDive/Controllers/External/SubscriptionAutomationPolicy.cs
@@ -8,7 +8,10 @@ internal sealed record UpsertSubscriptionAutomationPolicyRequest(
     long? MinSizeBytes,
     long? MaxSizeBytes,
     IReadOnlyList<string>? ExcludedKeywords,
-    string Mode);
+    string Mode,
+    bool EnableVersionUpgrade = false,
+    int? MinimumUpgradeScore = null,
+    int? UpgradeRollbackHours = null);
 
 internal sealed record SubscriptionAutomationPolicy(
     Guid FeedId,
@@ -21,7 +24,10 @@ internal sealed record SubscriptionAutomationPolicy(
     IReadOnlyList<string> ExcludedKeywords,
     string Mode,
     DateTimeOffset CreatedAt,
-    DateTimeOffset UpdatedAt);
+    DateTimeOffset UpdatedAt,
+    bool EnableVersionUpgrade,
+    int MinimumUpgradeScore,
+    int UpgradeRollbackHours);
 
 internal sealed record SubscriptionAutomationExplanation(
     string Field,
diff --git a/SecondDimensionWatcherReDive/Controllers/LibraryController.cs b/SecondDimensionWatcherReDive/Controllers/LibraryController.cs
new file mode 100644
index 0000000..c06f84e
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Controllers/LibraryController.cs
@@ -0,0 +1,158 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
+
+namespace SecondDimensionWatcherReDive.Controllers;
+
+[ApiController]
+[Route("api/library")]
+[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
+internal sealed class LibraryController(
+    ILibrarySearchRepository searchRepository,
+    IReleaseUpgradeRepository upgradeRepository,
+    IReleaseUpgradeCoordinator upgradeCoordinator) : ControllerBase
+{
+    [HttpGet("search")]
+    public async Task<IActionResult> SearchAsync(
+        [FromQuery(Name = "q")] string? query,
+        [FromQuery] int? season,
+        [FromQuery] int? episode,
+        [FromQuery] string? subtitleGroup,
+        [FromQuery] string? resolution,
+        [FromQuery] string? codec,
+        [FromQuery] string? language,
+        [FromQuery] string? downloadState,
+        [FromQuery] string? watchState,
+        [FromQuery(Name = "path")] string? virtualPath,
+        [FromQuery] string? source,
+        [FromQuery] string? sort,
+        [FromQuery] string? cursor,
+        [FromQuery] int take = 30,
+        CancellationToken cancellationToken = default)
+    {
+        if (!TryGetUserId(out var userId)) return Unauthorized();
+        if (take is < 1 or > 100 || season is < 0 or > 100 || episode is < 0 or > 100000)
+            return BadRequest(new { message = "Invalid pagination, season, or episode value." });
+        if (!TryParse(downloadState, LibraryDownloadState.Any, out LibraryDownloadState parsedDownload) ||
+            !TryParse(watchState, LibraryWatchState.Any, out LibraryWatchState parsedWatch) ||
+            !TryParse(source, LibrarySourceKind.Any, out LibrarySourceKind parsedSource) ||
+            !TryParse(sort, LibrarySearchSort.PublishedDescending, out LibrarySearchSort parsedSort))
+            return BadRequest(new { message = "One or more search enum values are invalid." });
+
+        try
+        {
+            var result = await searchRepository.SearchAsync(new LibrarySearchRequest(
+                    Normalize(query),
+                    season,
+                    episode,
+                    Normalize(subtitleGroup),
+                    Normalize(resolution),
+                    Normalize(codec),
+                    Normalize(language),
+                    parsedDownload,
+                    parsedWatch,
+                    Normalize(virtualPath),
+                    parsedSource,
+                    parsedSort,
+                    Normalize(cursor),
+                    take,
+                    userId),
+                cancellationToken);
+            return Ok(result.ToExternal());
+        }
+        catch (ArgumentException exception)
+        {
+            return BadRequest(new
+            {
+                code = "library_cursor_invalidated",
+                message = exception.Message
+            });
+        }
+    }
+
+    [HttpGet("integrity")]
+    public async Task<IActionResult> IntegrityAsync(
+        [FromQuery] string? tmdbId,
+        [FromQuery] int? season,
+        CancellationToken cancellationToken)
+    {
+        if (season is < 0 or > 100) return BadRequest(new { message = "Invalid season." });
+        var result = await searchRepository.GetIntegrityAsync(Normalize(tmdbId), season, cancellationToken);
+        return Ok(result.Select(item => item.ToExternal()).ToList());
+    }
+
+    [HttpGet("upgrades")]
+    public async Task<IActionResult> UpgradesAsync(
+        [FromQuery] bool automaticOnly = false,
+        [FromQuery] int take = 50,
+        CancellationToken cancellationToken = default)
+    {
+        if (take is < 1 or > 200) return BadRequest(new { message = "take must be between 1 and 200." });
+        var result = await upgradeRepository.GetCandidatesAsync(automaticOnly, take, cancellationToken);
+        return Ok(result.Select(item => item.ToExternal()).ToList());
+    }
+
+    [HttpPost("upgrades/execute")]
+    public async Task<IActionResult> ExecuteUpgradeAsync(
+        [FromBody] External.ExecuteReleaseUpgradeRequest request,
+        CancellationToken cancellationToken)
+    {
+        var candidate = await upgradeRepository.FindCandidateAsync(
+            request.CurrentReleaseId,
+            request.CandidateReleaseId,
+            cancellationToken);
+        if (candidate is null)
+            return Conflict(new { message = "The requested release is no longer an available upgrade." });
+
+        var result = await upgradeCoordinator.ExecuteAsync(candidate, request.DryRun, cancellationToken);
+        var response = result.ToExternal();
+        return result.IsSuccess ? Ok(response) : UnprocessableEntity(response);
+    }
+
+    [HttpPost("upgrades/{operationId:guid}/rollback")]
+    public async Task<IActionResult> RollbackUpgradeAsync(
+        [FromRoute] Guid operationId,
+        CancellationToken cancellationToken)
+    {
+        var result = await upgradeCoordinator.RollbackAsync(operationId, cancellationToken);
+        var response = result.ToExternal();
+        if (result.Outcome == "not_found") return NotFound(response);
+        return result.IsSuccess ? Ok(response) : Conflict(response);
+    }
+
+    [HttpGet("upgrade-history")]
+    public async Task<IActionResult> UpgradeHistoryAsync(
+        [FromQuery] int take = 50,
+        CancellationToken cancellationToken = default)
+    {
+        if (take is < 1 or > 200) return BadRequest(new { message = "take must be between 1 and 200." });
+        var result = await upgradeRepository.GetHistoryAsync(take, cancellationToken);
+        return Ok(result.Select(item => item.ToExternal()).ToList());
+    }
+
+    private bool TryGetUserId(out Guid userId)
+    {
+        var raw = User.FindFirstValue("Id")
+                  ?? User.FindFirstValue(ClaimTypes.NameIdentifier)
+                  ?? User.FindFirstValue("sub");
+        return Guid.TryParse(raw, out userId);
+    }
+
+    private static string? Normalize(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
+    private static bool TryParse<T>(string? value, T defaultValue, out T parsed)
+        where T : struct, Enum
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            parsed = defaultValue;
+            return true;
+        }
+
+        return Enum.TryParse(value, ignoreCase: true, out parsed) && Enum.IsDefined(parsed);
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Controllers/SubscriptionPoliciesController.cs b/SecondDimensionWatcherReDive/Controllers/SubscriptionPoliciesController.cs
index cf1a204..53ffc87 100644
--- a/SecondDimensionWatcherReDive/Controllers/SubscriptionPoliciesController.cs
+++ b/SecondDimensionWatcherReDive/Controllers/SubscriptionPoliciesController.cs
@@ -128,6 +128,20 @@ private static bool TryCreatePolicy(
             return false;
         }
 
+        var minimumUpgradeScore = request.MinimumUpgradeScore ?? 25;
+        if (minimumUpgradeScore is < 1 or > 1000)
+        {
+            error = "minimumUpgradeScore must be between 1 and 1000.";
+            return false;
+        }
+
+        var rollbackHours = request.UpgradeRollbackHours ?? 72;
+        if (rollbackHours is < 1 or > 720)
+        {
+            error = "upgradeRollbackHours must be between 1 and 720.";
+            return false;
+        }
+
         policy = new SubscriptionAutomationPolicy(
             feedId,
             subtitleGroups,
@@ -139,7 +153,10 @@ private static bool TryCreatePolicy(
             excludedKeywords,
             mode,
             timestamp,
-            timestamp);
+            timestamp,
+            request.EnableVersionUpgrade,
+            minimumUpgradeScore,
+            rollbackHours);
         error = null;
         return true;
     }
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.Designer.cs b/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.Designer.cs
new file mode 100644
index 0000000..906cd00
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.Designer.cs
@@ -0,0 +1,1441 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SecondDimensionWatcherReDive.Models;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20260831053426_AddLibrarySearchAndReleaseUpgrades")]
+    partial class AddLibrarySearchAndReleaseUpgrades
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Animation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.ToTable("Animations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AutomationAttentionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("LatestPublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReleaseCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AnimationId");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
+                    b.ToTable("AnimationCatalogEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AnimationCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AnimationGroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AdditionalDownloadInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AutomationDisposition")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("AutomationExplanationJson")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("CachedDownloadData")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("CurrentMetadataReviewOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DownloadAttemptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadCancellationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DownloadEndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("DownloadStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DownloadType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FileStore")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadTracked")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MediaLibrarySourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("MetadataConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetadataLastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset?>("MetadataReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ReleaseSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SourceFeedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("StateVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StorePath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentMetadataReviewOperationId")
+                        .IsUnique();
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("MediaLibrarySourceId");
+
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
+                    b.HasIndex("SourceFeedId");
+
+                    b.HasIndex("FileStore", "StorePath")
+                        .IsUnique()
+                        .HasFilter("\"DownloadType\" = 'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/media-library-import'");
+
+                    b.HasIndex("MetadataStatus", "PublishTime");
+
+                    b.HasIndex("AnimationId", "PublishTime", "Id");
+
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
+                    b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
+
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
+                    b.ToTable("AnimationInfo", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProtectedSecrets")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Revision")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ValuesJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings", t =>
+                        {
+                            t.HasCheckConstraint("CK_ApplicationSettings_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_ApplicationSettings_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AuthenticationState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ClaimId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("RegisteredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuthenticationStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AuthenticationStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MikanSubgroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("SeasonBangumiId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonBangumiId", "MikanSubgroupId")
+                        .IsUnique();
+
+                    b.ToTable("BangumiSubgroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatConversations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConversationId");
+
+                    b.ToTable("ChatMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Feed", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feeds");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("FileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationId", "CreatedAt");
+
+                    b.HasIndex("AnimationId", "Pattern")
+                        .IsUnique();
+
+                    b.ToTable("FileNameRegexRules");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemDirectoryState", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Generation")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Path");
+
+                    b.ToTable("FileSystemDirectoryStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemDirectoryStates_Generation_Positive", "\"Generation\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Cookie")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValueSql("nextval('sdw_file_system_entry_cookie_seq')");
+
+                    b.Property<int>("DescendantFileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("EntryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<Guid?>("FileMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDirectory")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Path");
+
+                    b.HasIndex("Cookie")
+                        .IsUnique();
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.HasIndex("FileMappingId")
+                        .IsUnique()
+                        .HasFilter("\"FileMappingId\" IS NOT NULL");
+
+                    b.HasIndex("ParentPath", "Cookie");
+
+                    b.HasIndex("ParentPath", "IsDirectory", "Name")
+                        .IsDescending(false, true, false);
+
+                    b.ToTable("FileSystemEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemEntries_NodeShape", "(\"IsDirectory\" AND \"FileMappingId\" IS NULL AND \"DescendantFileCount\" > 0) OR (NOT \"IsDirectory\" AND \"FileMappingId\" IS NOT NULL AND \"DescendantFileCount\" = 1)");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Incident", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Detail")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("DetectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Fingerprint")
+                        .IsRequired()
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<DateTimeOffset?>("LastRetryAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRetryError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Fingerprint")
+                        .IsUnique();
+
+                    b.HasIndex("ResolvedAt", "Type", "UpdatedAt");
+
+                    b.ToTable("Incidents");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MediaLibrarySource", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsMonitoring")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("LastImportedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastRemovedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("LastScanAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LastSkippedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastUpdatedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaLibrarySources");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("MetadataReviewMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("AppliedVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("BaseFileStore")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BaseIsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BaseStorePath")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BaseVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousAiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousAnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("PreviousConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("PreviousCurrentOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PreviousDescription")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("PreviousIsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PreviousLastError")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousMetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("PreviousReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedAnimationName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationOriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationPosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationTmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("UndoneAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "AppliedVersion")
+                        .IsUnique();
+
+                    b.HasIndex("AnimationInfoId", "State");
+
+                    b.HasIndex("State", "ExpiresAt");
+
+                    b.ToTable("MetadataReviewOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewOperations_Expiry", "\"ExpiresAt\" > \"CreatedAt\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MigrationExecutionState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<int>("AttemptCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Checkpoint")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("FinishedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastErrorSummary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(3);
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.HasKey("Key", "Version");
+
+                    b.ToTable("MigrationMarkers", null, t =>
+                        {
+                            t.HasCheckConstraint("CK_MigrationMarkers_AttemptCount_NonNegative", "\"AttemptCount\" >= 0");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Status_Range", "\"Status\" BETWEEN 0 AND 3");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Version_Positive", "\"Version\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedNever()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AudioTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("AutoPlayNext")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SubtitleLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("SubtitleTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackPreferences");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("DurationSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IsWatched")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("PositionSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("WatchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("UserId", "AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "IsWatched", "UpdatedAt");
+
+                    b.ToTable("PlaybackProgresses", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Duration_NonNegative", "\"DurationSeconds\" >= 0");
+
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Position_NonNegative", "\"PositionSeconds\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MikanId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MikanId")
+                        .IsUnique();
+
+                    b.ToTable("SeasonBangumis");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.Property<Guid>("FeedId")
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<string[]>("Codecs")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
+                    b.PrimitiveCollection<string[]>("ExcludedKeywords")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("Languages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long?>("MaxSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("MinSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("Resolutions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SubtitleGroups")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
+                    b.HasKey("FeedId");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebDavToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("WebDavTokens");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", "AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Animation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithMany()
+                        .HasForeignKey("AnimationId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationGroup", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MediaLibrarySource", null)
+                        .WithMany()
+                        .HasForeignKey("MediaLibrarySourceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", null)
+                        .WithMany()
+                        .HasForeignKey("SourceFeedId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Animation");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.SeasonBangumi", "SeasonBangumi")
+                        .WithMany("Subgroups")
+                        .HasForeignKey("SeasonBangumiId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SeasonBangumi");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ChatConversation", "Conversation")
+                        .WithMany("Messages")
+                        .HasForeignKey("ConversationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Conversation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.FileMapping", "FileMapping")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.FileSystemEntry", "FileMappingId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("FileMapping");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", "FeedId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Feed");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Navigation("Subgroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.cs b/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.cs
new file mode 100644
index 0000000..06d8d7d
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831053426_AddLibrarySearchAndReleaseUpgrades.cs
@@ -0,0 +1,568 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLibrarySearchAndReleaseUpgrades : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "EnableVersionUpgrade",
+                table: "SubscriptionAutomationPolicies",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MinimumUpgradeScore",
+                table: "SubscriptionAutomationPolicies",
+                type: "integer",
+                nullable: false,
+                defaultValue: 25);
+
+            migrationBuilder.AddColumn<int>(
+                name: "UpgradeRollbackHours",
+                table: "SubscriptionAutomationPolicies",
+                type: "integer",
+                nullable: false,
+                defaultValue: 72);
+
+            migrationBuilder.AddColumn<string>(
+                name: "EnclosureId",
+                table: "AnimationInfo",
+                type: "character varying(2048)",
+                maxLength: 2048,
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ExpectedEpisodeCount",
+                table: "AnimationInfo",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "FeedItemGuid",
+                table: "AnimationInfo",
+                type: "character varying(1024)",
+                maxLength: 1024,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "IngestedAt",
+                table: "AnimationInfo",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValueSql: "CURRENT_TIMESTAMP");
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsActiveRelease",
+                table: "AnimationInfo",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ReleaseCodec",
+                table: "AnimationInfo",
+                type: "character varying(32)",
+                maxLength: 32,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ReleaseIdentity",
+                table: "AnimationInfo",
+                type: "character varying(192)",
+                maxLength: 192,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string[]>(
+                name: "ReleaseLanguages",
+                table: "AnimationInfo",
+                type: "text[]",
+                nullable: false,
+                defaultValue: new string[0]);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ReleaseResolution",
+                table: "AnimationInfo",
+                type: "character varying(32)",
+                maxLength: 32,
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "ReleaseScore",
+                table: "AnimationInfo",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ReleaseScoreReasonsJson",
+                table: "AnimationInfo",
+                type: "text",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ReleaseSubtitleGroup",
+                table: "AnimationInfo",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TorrentInfoHash",
+                table: "AnimationInfo",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            // Existing releases predate stable external identities. Preserve every
+            // historical row, but assign the canonical torrent identity to exactly
+            // one row per valid infohash so a later concurrent feed sync deduplicates it.
+            migrationBuilder.Sql(
+                """
+                UPDATE "AnimationInfo"
+                SET "ReleaseIdentity" = 'legacy:' || replace(lower("Id"::text), '-', '');
+
+                WITH ranked_torrents AS (
+                    SELECT
+                        info."Id",
+                        lower(trim(info."AdditionalDownloadInfo")) AS infohash,
+                        row_number() OVER (
+                            PARTITION BY lower(trim(info."AdditionalDownloadInfo"))
+                            ORDER BY info."PublishTime", info."Id") AS identity_rank
+                    FROM "AnimationInfo" AS info
+                    WHERE info."DownloadType" =
+                              'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/torrent'
+                      AND trim(info."AdditionalDownloadInfo") ~* '^[0-9a-f]{40}$'
+                )
+                UPDATE "AnimationInfo" AS info
+                SET "TorrentInfoHash" = ranked.infohash,
+                    "ReleaseIdentity" = CASE
+                        WHEN ranked.identity_rank = 1 THEN 'torrent:' || ranked.infohash
+                        ELSE info."ReleaseIdentity"
+                    END
+                FROM ranked_torrents AS ranked
+                WHERE info."Id" = ranked."Id";
+
+                -- Keep the release that already owns the established primary video
+                -- path active. A suffix is treated as FileMapper's collision ordinal
+                -- only when the unsuffixed sibling exists for this episode; legitimate
+                -- titles/directories containing "(2)" therefore remain ordinal one.
+                -- This keeps the incumbent mapping and its playback rows addressable
+                -- until an explicit role-aware activation moves ownership.
+                WITH ranked_active_releases AS (
+                    SELECT
+                        info."Id",
+                        row_number() OVER (
+                            PARTITION BY info."AnimationId", info."Season", info."Episode"
+                            ORDER BY
+                                COALESCE((
+                                 SELECT min(
+                                     CASE
+                                         WHEN mapping."VirtualPath" ~
+                                                  ' \(([2-9]|[1-9][0-9]+)\)(\.[^/]+)$'
+                                              AND EXISTS (
+                                                  SELECT 1
+                                                  FROM "FileMappings" AS base_mapping
+                                                  JOIN "AnimationInfo" AS base_info
+                                                    ON base_info."Id" = base_mapping."AnimationInfoId"
+                                                  WHERE base_info."AnimationId" = info."AnimationId"
+                                                    AND base_info."Season" = info."Season"
+                                                    AND base_info."Episode" = info."Episode"
+                                                    AND base_mapping."VirtualPath" = regexp_replace(
+                                                        mapping."VirtualPath",
+                                                        ' \(([2-9]|[1-9][0-9]+)\)(\.[^/]+)$',
+                                                        '\2')
+                                              )
+                                             THEN (regexp_match(
+                                                 mapping."VirtualPath",
+                                                 ' \(([2-9]|[1-9][0-9]+)\)(\.[^/]+)$'))[1]::numeric
+                                         WHEN EXISTS (
+                                             SELECT 1
+                                             FROM "FileMappings" AS suffixed_mapping
+                                             JOIN "AnimationInfo" AS suffixed_info
+                                               ON suffixed_info."Id" = suffixed_mapping."AnimationInfoId"
+                                             WHERE suffixed_info."AnimationId" = info."AnimationId"
+                                               AND suffixed_info."Season" = info."Season"
+                                               AND suffixed_info."Episode" = info."Episode"
+                                               AND suffixed_mapping."VirtualPath" ~
+                                                   ' \(([2-9]|[1-9][0-9]+)\)(\.[^/]+)$'
+                                               AND regexp_replace(
+                                                   suffixed_mapping."VirtualPath",
+                                                   ' \(([2-9]|[1-9][0-9]+)\)(\.[^/]+)$',
+                                                   '\2') = mapping."VirtualPath"
+                                         )
+                                             THEN 1
+                                         ELSE NULL
+                                     END)
+                                 FROM "FileMappings" AS mapping
+                                 WHERE mapping."AnimationInfoId" = info."Id"
+                                   AND split_part(mapping."VirtualPath", '/', 4) <> ''
+                                   AND split_part(mapping."VirtualPath", '/', 5) = ''
+                                   AND regexp_replace(
+                                           regexp_replace(
+                                               regexp_replace(
+                                                   mapping."VirtualPath", '^.*/', ''),
+                                               '\.[^./]+$', ''),
+                                           ' \(([2-9]|[1-9][0-9]+)\)$', '') =
+                                       split_part(mapping."VirtualPath", '/', 2) ||
+                                       ' S' || lpad(info."Season"::text, 2, '0') ||
+                                       'E' || lpad(info."Episode"::text, 2, '0')
+                                   AND lower(mapping."VirtualPath") ~
+                                       '\.(mkv|mp4|avi|flv|wmv|webm|mov|m4v|ts|m2ts)$'),
+                                 9223372036854775807) ASC,
+                                info."PublishTime",
+                                info."Id") AS active_rank
+                    FROM "AnimationInfo" AS info
+                    WHERE info."AnimationId" IS NOT NULL
+                      AND info."Season" IS NOT NULL
+                      AND info."Episode" IS NOT NULL
+                      AND info."MediaLibraryMissingSince" IS NULL
+                      AND info."IsDownloadFinished"
+                      AND EXISTS (
+                          SELECT 1
+                          FROM "FileMappings" AS mapping
+                          WHERE mapping."AnimationInfoId" = info."Id")
+                )
+                UPDATE "AnimationInfo" AS info
+                SET "IsActiveRelease" = ranked.active_rank = 1
+                FROM ranked_active_releases AS ranked
+                WHERE info."Id" = ranked."Id";
+
+                CREATE EXTENSION IF NOT EXISTS pg_trgm;
+                """);
+
+            migrationBuilder.CreateTable(
+                name: "ReleaseUpgradeOperations",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrentReleaseId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CandidateReleaseId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Status = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    CurrentScore = table.Column<int>(type: "integer", nullable: false),
+                    CandidateScore = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    VerifiedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    AppliedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    RollbackUntil = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    CompletedAt = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    FailureSummary = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ReleaseUpgradeOperations", x => x.Id);
+                    table.CheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                    table.ForeignKey(
+                        name: "FK_ReleaseUpgradeOperations_AnimationInfo_CandidateReleaseId",
+                        column: x => x.CandidateReleaseId,
+                        principalTable: "AnimationInfo",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_ReleaseUpgradeOperations_AnimationInfo_CurrentReleaseId",
+                        column: x => x.CurrentReleaseId,
+                        principalTable: "AnimationInfo",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ReleaseUpgradeMappingSnapshots",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    OperationId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Kind = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    OriginalMappingId = table.Column<Guid>(type: "uuid", nullable: false),
+                    AnimationInfoId = table.Column<Guid>(type: "uuid", nullable: false),
+                    VirtualPath = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    PhysicalPath = table.Column<string>(type: "text", nullable: false),
+                    FileStore = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ReleaseUpgradeMappingSnapshots", x => x.Id);
+                    table.CheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                    table.ForeignKey(
+                        name: "FK_ReleaseUpgradeMappingSnapshots_ReleaseUpgradeOperations_Ope~",
+                        column: x => x.OperationId,
+                        principalTable: "ReleaseUpgradeOperations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            // This is an operational snapshot rather than an application entity.
+            // Keep every old file/directory identity so a rollback can restore
+            // NFS file handles even when an old-only branch disappeared during
+            // activation. Repository code reads and writes it with set-based SQL.
+            migrationBuilder.CreateTable(
+                name: "ReleaseUpgradeEntryIdentitySnapshots",
+                columns: table => new
+                {
+                    OperationId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Path = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    EntryId = table.Column<Guid>(type: "uuid", nullable: false),
+                    IsDirectory = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey(
+                        "PK_ReleaseUpgradeEntryIdentitySnapshots",
+                        x => new { x.OperationId, x.Path });
+                    table.CheckConstraint(
+                        "CK_ReleaseUpgradeEntryIdentitySnapshots_Path_Canonical",
+                        "\"Path\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"Path\" !~ '(^|/)\\.\\.?($|/)'");
+                    table.ForeignKey(
+                        name: "FK_ReleaseUpgradeEntryIdentitySnapshots_ReleaseUpgradeOperations_OperationId",
+                        column: x => x.OperationId,
+                        principalTable: "ReleaseUpgradeOperations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.AddCheckConstraint(
+                name: "CK_SubscriptionAutomationPolicies_MinimumUpgradeScore",
+                table: "SubscriptionAutomationPolicies",
+                sql: "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+            migrationBuilder.AddCheckConstraint(
+                name: "CK_SubscriptionAutomationPolicies_UpgradeRollbackHours",
+                table: "SubscriptionAutomationPolicies",
+                sql: "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AnimationInfo_DownloadType_IsDownloadFinished_IsDownloadTra~",
+                table: "AnimationInfo",
+                columns: new[] { "DownloadType", "IsDownloadFinished", "IsDownloadTracked" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AnimationInfo_ReleaseCodec",
+                table: "AnimationInfo",
+                column: "ReleaseCodec");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AnimationInfo_ReleaseResolution",
+                table: "AnimationInfo",
+                column: "ReleaseResolution");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AnimationInfo_ReleaseSubtitleGroup",
+                table: "AnimationInfo",
+                column: "ReleaseSubtitleGroup");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AnimationInfo_Season_Episode_ReleaseScore",
+                table: "AnimationInfo",
+                columns: new[] { "Season", "Episode", "ReleaseScore" });
+
+            migrationBuilder.CreateIndex(
+                name: "UX_AnimationInfo_ActiveEpisodeRelease",
+                table: "AnimationInfo",
+                columns: new[] { "AnimationId", "Season", "Episode" },
+                unique: true,
+                filter: "\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+            migrationBuilder.CreateIndex(
+                name: "UX_AnimationInfo_ReleaseIdentity",
+                table: "AnimationInfo",
+                column: "ReleaseIdentity",
+                unique: true,
+                filter: "\"ReleaseIdentity\" IS NOT NULL");
+
+            migrationBuilder.AddCheckConstraint(
+                name: "CK_AnimationInfo_ExpectedEpisodeCount_Positive",
+                table: "AnimationInfo",
+                sql: "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+            migrationBuilder.AddCheckConstraint(
+                name: "CK_AnimationInfo_ReleaseScore_NonNegative",
+                table: "AnimationInfo",
+                sql: "\"ReleaseScore\" >= 0");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ReleaseUpgradeMappingSnapshots_OperationId_Kind_OriginalMap~",
+                table: "ReleaseUpgradeMappingSnapshots",
+                columns: new[] { "OperationId", "Kind", "OriginalMappingId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ReleaseUpgradeOperations_CandidateReleaseId",
+                table: "ReleaseUpgradeOperations",
+                column: "CandidateReleaseId",
+                unique: true,
+                filter: "\"Status\" <> 'Failed'");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ReleaseUpgradeOperations_Status_CreatedAt",
+                table: "ReleaseUpgradeOperations",
+                columns: new[] { "Status", "CreatedAt" });
+
+            migrationBuilder.CreateIndex(
+                name: "UX_ReleaseUpgradeOperations_ActiveCurrentRelease",
+                table: "ReleaseUpgradeOperations",
+                column: "CurrentReleaseId",
+                unique: true,
+                filter: "\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+            migrationBuilder.Sql(
+                """
+                CREATE INDEX "IX_AnimationInfo_Title_Trgm"
+                    ON "AnimationInfo" USING GIN ("Title" gin_trgm_ops);
+                CREATE INDEX "IX_AnimationInfo_Description_Trgm"
+                    ON "AnimationInfo" USING GIN ("Description" gin_trgm_ops);
+                CREATE INDEX "IX_Animations_Name_Trgm"
+                    ON "Animations" USING GIN ("Name" gin_trgm_ops);
+                CREATE INDEX "IX_Animations_OriginalName_Trgm"
+                    ON "Animations" USING GIN ("OriginalName" gin_trgm_ops);
+                CREATE INDEX "IX_Animations_TmdbId_Trgm"
+                    ON "Animations" USING GIN ("TmdbId" gin_trgm_ops);
+                CREATE INDEX "IX_AnimationGroups_Name_Trgm"
+                    ON "AnimationGroups" USING GIN ("Name" gin_trgm_ops);
+                CREATE INDEX "IX_FileMappings_VirtualPath_Trgm"
+                    ON "FileMappings" USING GIN ("VirtualPath" gin_trgm_ops);
+                CREATE INDEX "IX_AnimationInfo_ReleaseLanguages_Gin"
+                    ON "AnimationInfo" USING GIN ("ReleaseLanguages");
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                """
+                DROP INDEX IF EXISTS "IX_AnimationInfo_Title_Trgm";
+                DROP INDEX IF EXISTS "IX_AnimationInfo_Description_Trgm";
+                DROP INDEX IF EXISTS "IX_Animations_Name_Trgm";
+                DROP INDEX IF EXISTS "IX_Animations_OriginalName_Trgm";
+                DROP INDEX IF EXISTS "IX_Animations_TmdbId_Trgm";
+                DROP INDEX IF EXISTS "IX_AnimationGroups_Name_Trgm";
+                DROP INDEX IF EXISTS "IX_FileMappings_VirtualPath_Trgm";
+                DROP INDEX IF EXISTS "IX_AnimationInfo_ReleaseLanguages_Gin";
+                """);
+
+            migrationBuilder.DropTable(
+                name: "ReleaseUpgradeEntryIdentitySnapshots");
+
+            migrationBuilder.DropTable(
+                name: "ReleaseUpgradeMappingSnapshots");
+
+            migrationBuilder.DropTable(
+                name: "ReleaseUpgradeOperations");
+
+            migrationBuilder.DropCheckConstraint(
+                name: "CK_SubscriptionAutomationPolicies_MinimumUpgradeScore",
+                table: "SubscriptionAutomationPolicies");
+
+            migrationBuilder.DropCheckConstraint(
+                name: "CK_SubscriptionAutomationPolicies_UpgradeRollbackHours",
+                table: "SubscriptionAutomationPolicies");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AnimationInfo_DownloadType_IsDownloadFinished_IsDownloadTra~",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AnimationInfo_ReleaseCodec",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AnimationInfo_ReleaseResolution",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AnimationInfo_ReleaseSubtitleGroup",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AnimationInfo_Season_Episode_ReleaseScore",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "UX_AnimationInfo_ActiveEpisodeRelease",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropIndex(
+                name: "UX_AnimationInfo_ReleaseIdentity",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropCheckConstraint(
+                name: "CK_AnimationInfo_ExpectedEpisodeCount_Positive",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropCheckConstraint(
+                name: "CK_AnimationInfo_ReleaseScore_NonNegative",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "EnableVersionUpgrade",
+                table: "SubscriptionAutomationPolicies");
+
+            migrationBuilder.DropColumn(
+                name: "MinimumUpgradeScore",
+                table: "SubscriptionAutomationPolicies");
+
+            migrationBuilder.DropColumn(
+                name: "UpgradeRollbackHours",
+                table: "SubscriptionAutomationPolicies");
+
+            migrationBuilder.DropColumn(
+                name: "EnclosureId",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ExpectedEpisodeCount",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "FeedItemGuid",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "IngestedAt",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "IsActiveRelease",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseCodec",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseIdentity",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseLanguages",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseResolution",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseScore",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseScoreReasonsJson",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "ReleaseSubtitleGroup",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "TorrentInfoHash",
+                table: "AnimationInfo");
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.Designer.cs b/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.Designer.cs
new file mode 100644
index 0000000..7723a0c
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.Designer.cs
@@ -0,0 +1,1642 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SecondDimensionWatcherReDive.Models;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20260831071234_StageInactiveReleaseMappings")]
+    partial class StageInactiveReleaseMappings
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Animation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.ToTable("Animations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AutomationAttentionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("LatestPublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReleaseCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AnimationId");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
+                    b.ToTable("AnimationCatalogEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AnimationCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AnimationGroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AdditionalDownloadInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AutomationDisposition")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("AutomationExplanationJson")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("CachedDownloadData")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("CurrentMetadataReviewOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DownloadAttemptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadCancellationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DownloadEndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("DownloadStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DownloadType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FileStore")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadTracked")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MediaLibrarySourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("MetadataConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetadataLastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset?>("MetadataReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ReleaseSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SourceFeedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("StateVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StorePath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentMetadataReviewOperationId")
+                        .IsUnique();
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("MediaLibrarySourceId");
+
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
+                    b.HasIndex("SourceFeedId");
+
+                    b.HasIndex("AutomationDisposition", "PublishTime");
+
+                    b.HasIndex("FileStore", "StorePath")
+                        .IsUnique()
+                        .HasFilter("\"DownloadType\" = 'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/media-library-import'");
+
+                    b.HasIndex("MetadataStatus", "PublishTime");
+
+                    b.HasIndex("AnimationId", "PublishTime", "Id");
+
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
+                    b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
+
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
+                    b.ToTable("AnimationInfo", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProtectedSecrets")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Revision")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ValuesJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings", t =>
+                        {
+                            t.HasCheckConstraint("CK_ApplicationSettings_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_ApplicationSettings_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AuthenticationState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ClaimId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("RegisteredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuthenticationStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AuthenticationStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MikanSubgroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("SeasonBangumiId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonBangumiId", "MikanSubgroupId")
+                        .IsUnique();
+
+                    b.ToTable("BangumiSubgroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatConversations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConversationId");
+
+                    b.ToTable("ChatMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Feed", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feeds");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("FileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationId", "CreatedAt");
+
+                    b.HasIndex("AnimationId", "Pattern")
+                        .IsUnique();
+
+                    b.ToTable("FileNameRegexRules");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemDirectoryState", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Generation")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Path");
+
+                    b.ToTable("FileSystemDirectoryStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemDirectoryStates_Generation_Positive", "\"Generation\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Cookie")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValueSql("nextval('sdw_file_system_entry_cookie_seq')");
+
+                    b.Property<int>("DescendantFileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("EntryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<Guid?>("FileMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDirectory")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Path");
+
+                    b.HasIndex("Cookie")
+                        .IsUnique();
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.HasIndex("FileMappingId")
+                        .IsUnique()
+                        .HasFilter("\"FileMappingId\" IS NOT NULL");
+
+                    b.HasIndex("ParentPath", "Cookie");
+
+                    b.HasIndex("ParentPath", "IsDirectory", "Name")
+                        .IsDescending(false, true, false);
+
+                    b.ToTable("FileSystemEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemEntries_NodeShape", "(\"IsDirectory\" AND \"FileMappingId\" IS NULL AND \"DescendantFileCount\" > 0) OR (NOT \"IsDirectory\" AND \"FileMappingId\" IS NOT NULL AND \"DescendantFileCount\" = 1)");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Incident", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Detail")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("DetectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Fingerprint")
+                        .IsRequired()
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<DateTimeOffset?>("LastRetryAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRetryError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Occurrence")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Fingerprint")
+                        .IsUnique();
+
+                    b.HasIndex("ResolvedAt", "Type", "UpdatedAt");
+
+                    b.ToTable("Incidents", t =>
+                        {
+                            t.HasCheckConstraint("CK_Incidents_Occurrence_Positive", "\"Occurrence\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MediaLibrarySource", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsMonitoring")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("LastImportedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastRemovedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("LastScanAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LastSkippedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastUpdatedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaLibrarySources");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("MetadataReviewMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("AppliedVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("BaseFileStore")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BaseIsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BaseStorePath")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BaseVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousAiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousAnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("PreviousConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("PreviousCurrentOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PreviousDescription")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("PreviousIsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PreviousLastError")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousMetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("PreviousReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedAnimationName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationOriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationPosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationTmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("UndoneAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "AppliedVersion")
+                        .IsUnique();
+
+                    b.HasIndex("AnimationInfoId", "State");
+
+                    b.HasIndex("State", "ExpiresAt");
+
+                    b.ToTable("MetadataReviewOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewOperations_Expiry", "\"ExpiresAt\" > \"CreatedAt\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MigrationExecutionState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<int>("AttemptCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Checkpoint")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("FinishedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastErrorSummary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(3);
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.HasKey("Key", "Version");
+
+                    b.ToTable("MigrationMarkers", null, t =>
+                        {
+                            t.HasCheckConstraint("CK_MigrationMarkers_AttemptCount_NonNegative", "\"AttemptCount\" >= 0");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Status_Range", "\"Status\" BETWEEN 0 AND 3");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Version_Positive", "\"Version\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.NotificationOutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("DeduplicationKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DeepLink")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("DeliveredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("NextAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PayloadJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<Guid?>("WebPushSubscriptionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeduplicationKey")
+                        .IsUnique();
+
+                    b.HasIndex("WebPushSubscriptionId");
+
+                    b.HasIndex("Status", "NextAttemptAt");
+
+                    b.ToTable("NotificationOutboxMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AudioTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("AutoPlayNext")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SubtitleLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("SubtitleTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackPreferences");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("DurationSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IsWatched")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("PositionSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("WatchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("UserId", "AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "IsWatched", "UpdatedAt");
+
+                    b.ToTable("PlaybackProgresses", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Duration_NonNegative", "\"DurationSeconds\" >= 0");
+
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Position_NonNegative", "\"PositionSeconds\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MikanId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MikanId")
+                        .IsUnique();
+
+                    b.ToTable("SeasonBangumis");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("StagedFileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.Property<Guid>("FeedId")
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<string[]>("Codecs")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
+                    b.PrimitiveCollection<string[]>("ExcludedKeywords")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("Languages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long?>("MaxSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("MinSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("Resolutions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SubtitleGroups")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
+                    b.HasKey("FeedId");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.TodoItemState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset?>("ReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("SnoozedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("TodoItemStates");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebDavToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("WebDavTokens");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebPushSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EndpointHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset?>("LastFailureAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastSuccessAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ProtectedAuth")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ProtectedEndpoint")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<string>("ProtectedP256Dh")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EndpointHash")
+                        .IsUnique();
+
+                    b.ToTable("WebPushSubscriptions");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", "AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Animation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithMany()
+                        .HasForeignKey("AnimationId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationGroup", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MediaLibrarySource", null)
+                        .WithMany()
+                        .HasForeignKey("MediaLibrarySourceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", null)
+                        .WithMany()
+                        .HasForeignKey("SourceFeedId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Animation");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.SeasonBangumi", "SeasonBangumi")
+                        .WithMany("Subgroups")
+                        .HasForeignKey("SeasonBangumiId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SeasonBangumi");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ChatConversation", "Conversation")
+                        .WithMany("Messages")
+                        .HasForeignKey("ConversationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Conversation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.FileMapping", "FileMapping")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.FileSystemEntry", "FileMappingId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("FileMapping");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", "FeedId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Feed");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Navigation("Subgroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.cs b/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.cs
new file mode 100644
index 0000000..5eba90c
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831071234_StageInactiveReleaseMappings.cs
@@ -0,0 +1,102 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    /// <inheritdoc />
+    public partial class StageInactiveReleaseMappings : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "StagedFileMappings",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    AnimationInfoId = table.Column<Guid>(type: "uuid", nullable: false),
+                    VirtualPath = table.Column<string>(type: "character varying(2048)", maxLength: 2048, nullable: false),
+                    PhysicalPath = table.Column<string>(type: "text", nullable: false),
+                    FileStore = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_StagedFileMappings", x => x.Id);
+                    table.CheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                    table.ForeignKey(
+                        name: "FK_StagedFileMappings_AnimationInfo_AnimationInfoId",
+                        column: x => x.AnimationInfoId,
+                        principalTable: "AnimationInfo",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_StagedFileMappings_AnimationInfoId_VirtualPath",
+                table: "StagedFileMappings",
+                columns: new[] { "AnimationInfoId", "VirtualPath" },
+                unique: true);
+
+            // Alternative releases used to share the live FileMappings namespace.
+            // Move only known-episode alternatives that have a different active
+            // release; unknown/unmatched downloads remain ordinary live content.
+            migrationBuilder.Sql(
+                """
+                INSERT INTO "StagedFileMappings"
+                    ("Id", "AnimationInfoId", "VirtualPath", "PhysicalPath", "FileStore")
+                SELECT mapping."Id", mapping."AnimationInfoId", mapping."VirtualPath",
+                       mapping."PhysicalPath", mapping."FileStore"
+                FROM "FileMappings" AS mapping
+                JOIN "AnimationInfo" AS candidate
+                  ON candidate."Id" = mapping."AnimationInfoId"
+                WHERE NOT candidate."IsActiveRelease"
+                  AND candidate."AnimationId" IS NOT NULL
+                  AND candidate."Season" IS NOT NULL
+                  AND candidate."Episode" IS NOT NULL
+                  AND EXISTS (
+                      SELECT 1
+                      FROM "AnimationInfo" AS active
+                      WHERE active."Id" <> candidate."Id"
+                        AND active."IsActiveRelease"
+                        AND active."AnimationId" = candidate."AnimationId"
+                        AND active."Season" = candidate."Season"
+                        AND active."Episode" = candidate."Episode");
+
+                DELETE FROM "FileMappings" AS mapping
+                USING "AnimationInfo" AS candidate
+                WHERE candidate."Id" = mapping."AnimationInfoId"
+                  AND NOT candidate."IsActiveRelease"
+                  AND candidate."AnimationId" IS NOT NULL
+                  AND candidate."Season" IS NOT NULL
+                  AND candidate."Episode" IS NOT NULL
+                  AND EXISTS (
+                      SELECT 1
+                      FROM "AnimationInfo" AS active
+                      WHERE active."Id" <> candidate."Id"
+                        AND active."IsActiveRelease"
+                        AND active."AnimationId" = candidate."AnimationId"
+                        AND active."Season" = candidate."Season"
+                        AND active."Episode" = candidate."Episode");
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Fail the downgrade transaction if the live namespace changed in a
+            // way that prevents restoring every staged mapping; never discard it.
+            migrationBuilder.Sql(
+                """
+                INSERT INTO "FileMappings"
+                    ("Id", "AnimationInfoId", "VirtualPath", "PhysicalPath", "FileStore")
+                SELECT "Id", "AnimationInfoId", "VirtualPath", "PhysicalPath", "FileStore"
+                FROM "StagedFileMappings";
+                """);
+
+            migrationBuilder.DropTable(
+                name: "StagedFileMappings");
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.Designer.cs b/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.Designer.cs
new file mode 100644
index 0000000..2726676
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.Designer.cs
@@ -0,0 +1,1658 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SecondDimensionWatcherReDive.Models;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20260831073420_AddPlaybackCatalogRevisions")]
+    partial class AddPlaybackCatalogRevisions
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Animation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.ToTable("Animations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AutomationAttentionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("LatestPublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReleaseCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AnimationId");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
+                    b.ToTable("AnimationCatalogEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AnimationCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AnimationGroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AdditionalDownloadInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AutomationDisposition")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("AutomationExplanationJson")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("CachedDownloadData")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("CurrentMetadataReviewOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DownloadAttemptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadCancellationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DownloadEndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("DownloadStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DownloadType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FileStore")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadTracked")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MediaLibrarySourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("MetadataConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetadataLastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset?>("MetadataReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ReleaseSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SourceFeedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("StateVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StorePath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentMetadataReviewOperationId")
+                        .IsUnique();
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("MediaLibrarySourceId");
+
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
+                    b.HasIndex("SourceFeedId");
+
+                    b.HasIndex("AutomationDisposition", "PublishTime");
+
+                    b.HasIndex("FileStore", "StorePath")
+                        .IsUnique()
+                        .HasFilter("\"DownloadType\" = 'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/media-library-import'");
+
+                    b.HasIndex("MetadataStatus", "PublishTime");
+
+                    b.HasIndex("AnimationId", "PublishTime", "Id");
+
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
+                    b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
+
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
+                    b.ToTable("AnimationInfo", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProtectedSecrets")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Revision")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ValuesJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings", t =>
+                        {
+                            t.HasCheckConstraint("CK_ApplicationSettings_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_ApplicationSettings_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AuthenticationState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ClaimId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("RegisteredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuthenticationStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AuthenticationStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MikanSubgroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("SeasonBangumiId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonBangumiId", "MikanSubgroupId")
+                        .IsUnique();
+
+                    b.ToTable("BangumiSubgroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatConversations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConversationId");
+
+                    b.ToTable("ChatMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Feed", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feeds");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("FileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationId", "CreatedAt");
+
+                    b.HasIndex("AnimationId", "Pattern")
+                        .IsUnique();
+
+                    b.ToTable("FileNameRegexRules");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemDirectoryState", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Generation")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Path");
+
+                    b.ToTable("FileSystemDirectoryStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemDirectoryStates_Generation_Positive", "\"Generation\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Cookie")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValueSql("nextval('sdw_file_system_entry_cookie_seq')");
+
+                    b.Property<int>("DescendantFileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("EntryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<Guid?>("FileMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDirectory")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Path");
+
+                    b.HasIndex("Cookie")
+                        .IsUnique();
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.HasIndex("FileMappingId")
+                        .IsUnique()
+                        .HasFilter("\"FileMappingId\" IS NOT NULL");
+
+                    b.HasIndex("ParentPath", "Cookie");
+
+                    b.HasIndex("ParentPath", "IsDirectory", "Name")
+                        .IsDescending(false, true, false);
+
+                    b.ToTable("FileSystemEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemEntries_NodeShape", "(\"IsDirectory\" AND \"FileMappingId\" IS NULL AND \"DescendantFileCount\" > 0) OR (NOT \"IsDirectory\" AND \"FileMappingId\" IS NOT NULL AND \"DescendantFileCount\" = 1)");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Incident", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Detail")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("DetectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Fingerprint")
+                        .IsRequired()
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<DateTimeOffset?>("LastRetryAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRetryError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Occurrence")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Fingerprint")
+                        .IsUnique();
+
+                    b.HasIndex("ResolvedAt", "Type", "UpdatedAt");
+
+                    b.ToTable("Incidents", t =>
+                        {
+                            t.HasCheckConstraint("CK_Incidents_Occurrence_Positive", "\"Occurrence\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MediaLibrarySource", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsMonitoring")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("LastImportedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastRemovedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("LastScanAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LastSkippedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastUpdatedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaLibrarySources");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("MetadataReviewMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("AppliedVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("BaseFileStore")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BaseIsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BaseStorePath")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BaseVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousAiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousAnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("PreviousConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("PreviousCurrentOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PreviousDescription")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("PreviousIsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PreviousLastError")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousMetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("PreviousReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedAnimationName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationOriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationPosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationTmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("UndoneAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "AppliedVersion")
+                        .IsUnique();
+
+                    b.HasIndex("AnimationInfoId", "State");
+
+                    b.HasIndex("State", "ExpiresAt");
+
+                    b.ToTable("MetadataReviewOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewOperations_Expiry", "\"ExpiresAt\" > \"CreatedAt\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MigrationExecutionState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<int>("AttemptCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Checkpoint")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("FinishedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastErrorSummary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(3);
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.HasKey("Key", "Version");
+
+                    b.ToTable("MigrationMarkers", null, t =>
+                        {
+                            t.HasCheckConstraint("CK_MigrationMarkers_AttemptCount_NonNegative", "\"AttemptCount\" >= 0");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Status_Range", "\"Status\" BETWEEN 0 AND 3");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Version_Positive", "\"Version\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.NotificationOutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("DeduplicationKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DeepLink")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("DeliveredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("NextAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PayloadJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<Guid?>("WebPushSubscriptionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeduplicationKey")
+                        .IsUnique();
+
+                    b.HasIndex("WebPushSubscriptionId");
+
+                    b.HasIndex("Status", "NextAttemptAt");
+
+                    b.ToTable("NotificationOutboxMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackCatalogState", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackCatalogStates_Revision_Positive", "\"Revision\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AudioTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("AutoPlayNext")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SubtitleLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("SubtitleTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackPreferences");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("DurationSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IsWatched")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("PositionSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("WatchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("UserId", "AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "IsWatched", "UpdatedAt");
+
+                    b.ToTable("PlaybackProgresses", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Duration_NonNegative", "\"DurationSeconds\" >= 0");
+
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Position_NonNegative", "\"PositionSeconds\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MikanId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MikanId")
+                        .IsUnique();
+
+                    b.ToTable("SeasonBangumis");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("StagedFileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.Property<Guid>("FeedId")
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<string[]>("Codecs")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
+                    b.PrimitiveCollection<string[]>("ExcludedKeywords")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("Languages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long?>("MaxSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("MinSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("Resolutions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SubtitleGroups")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
+                    b.HasKey("FeedId");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.TodoItemState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset?>("ReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("SnoozedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("TodoItemStates");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebDavToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("WebDavTokens");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebPushSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EndpointHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset?>("LastFailureAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastSuccessAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ProtectedAuth")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ProtectedEndpoint")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<string>("ProtectedP256Dh")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EndpointHash")
+                        .IsUnique();
+
+                    b.ToTable("WebPushSubscriptions");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", "AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Animation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithMany()
+                        .HasForeignKey("AnimationId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationGroup", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MediaLibrarySource", null)
+                        .WithMany()
+                        .HasForeignKey("MediaLibrarySourceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", null)
+                        .WithMany()
+                        .HasForeignKey("SourceFeedId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Animation");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.SeasonBangumi", "SeasonBangumi")
+                        .WithMany("Subgroups")
+                        .HasForeignKey("SeasonBangumiId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SeasonBangumi");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ChatConversation", "Conversation")
+                        .WithMany("Messages")
+                        .HasForeignKey("ConversationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Conversation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.FileMapping", "FileMapping")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.FileSystemEntry", "FileMappingId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("FileMapping");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", "FeedId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Feed");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Navigation("Subgroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.cs b/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.cs
new file mode 100644
index 0000000..ae8cabb
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831073420_AddPlaybackCatalogRevisions.cs
@@ -0,0 +1,191 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPlaybackCatalogRevisions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PlaybackCatalogStates",
+                columns: table => new
+                {
+                    UserId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Revision = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PlaybackCatalogStates", x => x.UserId);
+                    table.CheckConstraint("CK_PlaybackCatalogStates_Revision_Positive", "\"Revision\" > 0");
+                });
+
+            migrationBuilder.Sql(
+                """
+                INSERT INTO "PlaybackCatalogStates" ("UserId", "Revision")
+                SELECT DISTINCT "UserId", 1
+                FROM "PlaybackProgresses"
+                WHERE "IsWatched" OR "PositionSeconds" > 0;
+
+                CREATE FUNCTION sdw_bump_playback_catalog_revisions(user_ids uuid[]) RETURNS void AS $$
+                DECLARE
+                    expected integer;
+                    affected integer;
+                BEGIN
+                    IF user_ids IS NULL OR cardinality(user_ids) = 0 THEN
+                        RETURN;
+                    END IF;
+
+                    SELECT count(*) INTO expected
+                    FROM (
+                        SELECT DISTINCT user_id
+                        FROM unnest(user_ids) AS changed(user_id)
+                        WHERE user_id IS NOT NULL
+                    ) AS affected_users;
+                    IF expected = 0 THEN
+                        RETURN;
+                    END IF;
+
+                    INSERT INTO "PlaybackCatalogStates" AS state ("UserId", "Revision")
+                    SELECT DISTINCT user_id, 1
+                    FROM unnest(user_ids) AS changed(user_id)
+                    WHERE user_id IS NOT NULL
+                    ON CONFLICT ("UserId") DO UPDATE
+                    SET "Revision" = state."Revision" + 1
+                    WHERE state."Revision" < 9223372036854775807;
+                    GET DIAGNOSTICS affected = ROW_COUNT;
+                    IF affected <> expected THEN
+                        RAISE EXCEPTION 'Exhausted playback catalog revision';
+                    END IF;
+                END;
+                $$ LANGUAGE plpgsql;
+
+                CREATE FUNCTION sdw_playback_catalog_insert() RETURNS trigger AS $$
+                DECLARE
+                    affected_users uuid[];
+                BEGIN
+                    SELECT array_agg(DISTINCT "UserId") INTO affected_users
+                    FROM new_rows
+                    WHERE "IsWatched" OR "PositionSeconds" > 0;
+                    PERFORM sdw_bump_playback_catalog_revisions(affected_users);
+                    RETURN NULL;
+                END;
+                $$ LANGUAGE plpgsql;
+
+                CREATE FUNCTION sdw_playback_catalog_update() RETURNS trigger AS $$
+                DECLARE
+                    affected_users uuid[];
+                BEGIN
+                    SELECT array_agg(DISTINCT "UserId") INTO affected_users
+                    FROM (
+                        SELECT previous."UserId"
+                        FROM old_rows AS previous
+                        LEFT JOIN new_rows AS current ON current."Id" = previous."Id"
+                        WHERE (previous."IsWatched" OR previous."PositionSeconds" > 0)
+                          AND (
+                              current."Id" IS NULL
+                              OR current."UserId" <> previous."UserId"
+                              OR current."AnimationInfoId" <> previous."AnimationInfoId"
+                              OR CASE
+                                     WHEN current."IsWatched" THEN 2
+                                     WHEN current."PositionSeconds" > 0 THEN 1
+                                     ELSE 0
+                                 END <> CASE
+                                     WHEN previous."IsWatched" THEN 2
+                                     WHEN previous."PositionSeconds" > 0 THEN 1
+                                     ELSE 0
+                                 END)
+                        UNION
+                        SELECT current."UserId"
+                        FROM new_rows AS current
+                        LEFT JOIN old_rows AS previous ON previous."Id" = current."Id"
+                        WHERE (current."IsWatched" OR current."PositionSeconds" > 0)
+                          AND (
+                              previous."Id" IS NULL
+                              OR current."UserId" <> previous."UserId"
+                              OR current."AnimationInfoId" <> previous."AnimationInfoId"
+                              OR CASE
+                                     WHEN current."IsWatched" THEN 2
+                                     WHEN current."PositionSeconds" > 0 THEN 1
+                                     ELSE 0
+                                 END <> CASE
+                                     WHEN previous."IsWatched" THEN 2
+                                     WHEN previous."PositionSeconds" > 0 THEN 1
+                                     ELSE 0
+                                 END)
+                    ) AS changed;
+                    PERFORM sdw_bump_playback_catalog_revisions(affected_users);
+                    RETURN NULL;
+                END;
+                $$ LANGUAGE plpgsql;
+
+                CREATE FUNCTION sdw_playback_catalog_delete() RETURNS trigger AS $$
+                DECLARE
+                    affected_users uuid[];
+                BEGIN
+                    SELECT array_agg(DISTINCT "UserId") INTO affected_users
+                    FROM old_rows
+                    WHERE "IsWatched" OR "PositionSeconds" > 0;
+                    PERFORM sdw_bump_playback_catalog_revisions(affected_users);
+                    RETURN NULL;
+                END;
+                $$ LANGUAGE plpgsql;
+
+                CREATE FUNCTION sdw_playback_catalog_truncate() RETURNS trigger AS $$
+                DECLARE
+                    affected_users uuid[];
+                BEGIN
+                    SELECT array_agg(DISTINCT "UserId") INTO affected_users
+                    FROM "PlaybackProgresses"
+                    WHERE "IsWatched" OR "PositionSeconds" > 0;
+                    PERFORM sdw_bump_playback_catalog_revisions(affected_users);
+                    RETURN NULL;
+                END;
+                $$ LANGUAGE plpgsql;
+
+                CREATE TRIGGER "TR_PlaybackProgresses_CatalogInsert"
+                AFTER INSERT ON "PlaybackProgresses"
+                REFERENCING NEW TABLE AS new_rows
+                FOR EACH STATEMENT EXECUTE FUNCTION sdw_playback_catalog_insert();
+
+                CREATE TRIGGER "TR_PlaybackProgresses_CatalogUpdate"
+                AFTER UPDATE ON "PlaybackProgresses"
+                REFERENCING OLD TABLE AS old_rows NEW TABLE AS new_rows
+                FOR EACH STATEMENT EXECUTE FUNCTION sdw_playback_catalog_update();
+
+                CREATE TRIGGER "TR_PlaybackProgresses_CatalogDelete"
+                AFTER DELETE ON "PlaybackProgresses"
+                REFERENCING OLD TABLE AS old_rows
+                FOR EACH STATEMENT EXECUTE FUNCTION sdw_playback_catalog_delete();
+
+                CREATE TRIGGER "TR_PlaybackProgresses_CatalogTruncate"
+                BEFORE TRUNCATE ON "PlaybackProgresses"
+                FOR EACH STATEMENT EXECUTE FUNCTION sdw_playback_catalog_truncate();
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                """
+                DROP TRIGGER "TR_PlaybackProgresses_CatalogInsert" ON "PlaybackProgresses";
+                DROP TRIGGER "TR_PlaybackProgresses_CatalogUpdate" ON "PlaybackProgresses";
+                DROP TRIGGER "TR_PlaybackProgresses_CatalogDelete" ON "PlaybackProgresses";
+                DROP TRIGGER "TR_PlaybackProgresses_CatalogTruncate" ON "PlaybackProgresses";
+                DROP FUNCTION sdw_playback_catalog_insert();
+                DROP FUNCTION sdw_playback_catalog_update();
+                DROP FUNCTION sdw_playback_catalog_delete();
+                DROP FUNCTION sdw_playback_catalog_truncate();
+                DROP FUNCTION sdw_bump_playback_catalog_revisions(uuid[]);
+                """);
+
+            migrationBuilder.DropTable(
+                name: "PlaybackCatalogStates");
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.Designer.cs b/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.Designer.cs
new file mode 100644
index 0000000..0a7b21e
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.Designer.cs
@@ -0,0 +1,1661 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SecondDimensionWatcherReDive.Models;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20260831083933_AddRetiredReleaseMarker")]
+    partial class AddRetiredReleaseMarker
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Animation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.ToTable("Animations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AutomationAttentionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("LatestPublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReleaseCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AnimationId");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
+                    b.ToTable("AnimationCatalogEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AnimationCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AnimationGroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AdditionalDownloadInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AutomationDisposition")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("AutomationExplanationJson")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("CachedDownloadData")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("CurrentMetadataReviewOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DownloadAttemptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadCancellationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DownloadEndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("DownloadStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DownloadType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FileStore")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadTracked")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsRetiredRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MediaLibrarySourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("MetadataConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetadataLastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset?>("MetadataReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ReleaseSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SourceFeedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("StateVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StorePath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentMetadataReviewOperationId")
+                        .IsUnique();
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("MediaLibrarySourceId");
+
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
+                    b.HasIndex("SourceFeedId");
+
+                    b.HasIndex("AutomationDisposition", "PublishTime");
+
+                    b.HasIndex("FileStore", "StorePath")
+                        .IsUnique()
+                        .HasFilter("\"DownloadType\" = 'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/media-library-import'");
+
+                    b.HasIndex("MetadataStatus", "PublishTime");
+
+                    b.HasIndex("AnimationId", "PublishTime", "Id");
+
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
+                    b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
+
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
+                    b.ToTable("AnimationInfo", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProtectedSecrets")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Revision")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ValuesJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings", t =>
+                        {
+                            t.HasCheckConstraint("CK_ApplicationSettings_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_ApplicationSettings_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AuthenticationState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ClaimId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("RegisteredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuthenticationStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AuthenticationStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MikanSubgroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("SeasonBangumiId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonBangumiId", "MikanSubgroupId")
+                        .IsUnique();
+
+                    b.ToTable("BangumiSubgroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatConversations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConversationId");
+
+                    b.ToTable("ChatMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Feed", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feeds");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("FileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationId", "CreatedAt");
+
+                    b.HasIndex("AnimationId", "Pattern")
+                        .IsUnique();
+
+                    b.ToTable("FileNameRegexRules");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemDirectoryState", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Generation")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Path");
+
+                    b.ToTable("FileSystemDirectoryStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemDirectoryStates_Generation_Positive", "\"Generation\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Cookie")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValueSql("nextval('sdw_file_system_entry_cookie_seq')");
+
+                    b.Property<int>("DescendantFileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("EntryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<Guid?>("FileMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDirectory")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Path");
+
+                    b.HasIndex("Cookie")
+                        .IsUnique();
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.HasIndex("FileMappingId")
+                        .IsUnique()
+                        .HasFilter("\"FileMappingId\" IS NOT NULL");
+
+                    b.HasIndex("ParentPath", "Cookie");
+
+                    b.HasIndex("ParentPath", "IsDirectory", "Name")
+                        .IsDescending(false, true, false);
+
+                    b.ToTable("FileSystemEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemEntries_NodeShape", "(\"IsDirectory\" AND \"FileMappingId\" IS NULL AND \"DescendantFileCount\" > 0) OR (NOT \"IsDirectory\" AND \"FileMappingId\" IS NOT NULL AND \"DescendantFileCount\" = 1)");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Incident", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Detail")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("DetectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Fingerprint")
+                        .IsRequired()
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<DateTimeOffset?>("LastRetryAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRetryError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Occurrence")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Fingerprint")
+                        .IsUnique();
+
+                    b.HasIndex("ResolvedAt", "Type", "UpdatedAt");
+
+                    b.ToTable("Incidents", t =>
+                        {
+                            t.HasCheckConstraint("CK_Incidents_Occurrence_Positive", "\"Occurrence\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MediaLibrarySource", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsMonitoring")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("LastImportedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastRemovedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("LastScanAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LastSkippedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastUpdatedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaLibrarySources");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("MetadataReviewMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("AppliedVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("BaseFileStore")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BaseIsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BaseStorePath")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BaseVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousAiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousAnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("PreviousConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("PreviousCurrentOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PreviousDescription")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("PreviousIsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PreviousLastError")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousMetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("PreviousReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedAnimationName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationOriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationPosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationTmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("UndoneAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "AppliedVersion")
+                        .IsUnique();
+
+                    b.HasIndex("AnimationInfoId", "State");
+
+                    b.HasIndex("State", "ExpiresAt");
+
+                    b.ToTable("MetadataReviewOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewOperations_Expiry", "\"ExpiresAt\" > \"CreatedAt\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MigrationExecutionState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<int>("AttemptCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Checkpoint")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("FinishedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastErrorSummary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(3);
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.HasKey("Key", "Version");
+
+                    b.ToTable("MigrationMarkers", null, t =>
+                        {
+                            t.HasCheckConstraint("CK_MigrationMarkers_AttemptCount_NonNegative", "\"AttemptCount\" >= 0");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Status_Range", "\"Status\" BETWEEN 0 AND 3");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Version_Positive", "\"Version\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.NotificationOutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("DeduplicationKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DeepLink")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("DeliveredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("NextAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PayloadJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<Guid?>("WebPushSubscriptionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeduplicationKey")
+                        .IsUnique();
+
+                    b.HasIndex("WebPushSubscriptionId");
+
+                    b.HasIndex("Status", "NextAttemptAt");
+
+                    b.ToTable("NotificationOutboxMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackCatalogState", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackCatalogStates_Revision_Positive", "\"Revision\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AudioTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("AutoPlayNext")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SubtitleLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("SubtitleTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackPreferences");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("DurationSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IsWatched")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("PositionSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("WatchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("UserId", "AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "IsWatched", "UpdatedAt");
+
+                    b.ToTable("PlaybackProgresses", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Duration_NonNegative", "\"DurationSeconds\" >= 0");
+
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Position_NonNegative", "\"PositionSeconds\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MikanId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MikanId")
+                        .IsUnique();
+
+                    b.ToTable("SeasonBangumis");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("StagedFileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.Property<Guid>("FeedId")
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<string[]>("Codecs")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
+                    b.PrimitiveCollection<string[]>("ExcludedKeywords")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("Languages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long?>("MaxSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("MinSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("Resolutions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SubtitleGroups")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
+                    b.HasKey("FeedId");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.TodoItemState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset?>("ReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("SnoozedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("TodoItemStates");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebDavToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("WebDavTokens");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebPushSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EndpointHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset?>("LastFailureAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastSuccessAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ProtectedAuth")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ProtectedEndpoint")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<string>("ProtectedP256Dh")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EndpointHash")
+                        .IsUnique();
+
+                    b.ToTable("WebPushSubscriptions");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", "AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Animation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithMany()
+                        .HasForeignKey("AnimationId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationGroup", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MediaLibrarySource", null)
+                        .WithMany()
+                        .HasForeignKey("MediaLibrarySourceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", null)
+                        .WithMany()
+                        .HasForeignKey("SourceFeedId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Animation");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.SeasonBangumi", "SeasonBangumi")
+                        .WithMany("Subgroups")
+                        .HasForeignKey("SeasonBangumiId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SeasonBangumi");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ChatConversation", "Conversation")
+                        .WithMany("Messages")
+                        .HasForeignKey("ConversationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Conversation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.FileMapping", "FileMapping")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.FileSystemEntry", "FileMappingId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("FileMapping");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", "FeedId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Feed");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Navigation("Subgroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.cs b/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.cs
new file mode 100644
index 0000000..a25364a
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831083933_AddRetiredReleaseMarker.cs
@@ -0,0 +1,47 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddRetiredReleaseMarker : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsRetiredRelease",
+                table: "AnimationInfo",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.Sql(
+                """
+                UPDATE "AnimationInfo" AS info
+                SET "IsRetiredRelease" = TRUE
+                WHERE NOT info."IsActiveRelease"
+                  AND (
+                      EXISTS (
+                          SELECT 1
+                          FROM "ReleaseUpgradeOperations" AS operation
+                          WHERE operation."CurrentReleaseId" = info."Id"
+                            AND operation."Status" IN ('Applied', 'Completed'))
+                      OR EXISTS (
+                          SELECT 1
+                          FROM "ReleaseUpgradeOperations" AS operation
+                          WHERE operation."CandidateReleaseId" = info."Id"
+                            AND operation."Status" = 'RolledBack'));
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsRetiredRelease",
+                table: "AnimationInfo");
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.Designer.cs b/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.Designer.cs
new file mode 100644
index 0000000..dc0804a
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.Designer.cs
@@ -0,0 +1,1691 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SecondDimensionWatcherReDive.Models;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    [DbContext(typeof(ApplicationContext))]
+    [Migration("20260831090146_AddReleaseUpgradeSubmissionRecovery")]
+    partial class AddReleaseUpgradeSubmissionRecovery
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.11")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Animation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.ToTable("Animations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AutomationAttentionCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("LatestPublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReleaseCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("AnimationId");
+
+                    b.HasIndex("TmdbId")
+                        .IsUnique();
+
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
+                    b.ToTable("AnimationCatalogEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AnimationCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationCatalogStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AnimationGroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AdditionalDownloadInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("AiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AutomationDisposition")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("AutomationExplanationJson")
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("CachedDownloadData")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("CurrentMetadataReviewOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DownloadAttemptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadSubmissionLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmissionLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DownloadCancellationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DownloadCancellationLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadCancellationLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("DownloadCancellationRemoveFile")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("DownloadEndTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("DownloadStartTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DownloadType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("FileStore")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDownloadTracked")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsRetiredRelease")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MediaLibrarySourceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("MetadataConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetadataLastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset?>("MetadataReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PublishTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("ReleaseSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("SourceFeedId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("StateVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StorePath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CurrentMetadataReviewOperationId")
+                        .IsUnique();
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("MediaLibrarySourceId");
+
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
+                    b.HasIndex("SourceFeedId");
+
+                    b.HasIndex("AutomationDisposition", "PublishTime");
+
+                    b.HasIndex("FileStore", "StorePath")
+                        .IsUnique()
+                        .HasFilter("\"DownloadType\" = 'http://schemas.hcgstudio.com/ws/2023/06/sdw/downloadtype/media-library-import'");
+
+                    b.HasIndex("MetadataStatus", "PublishTime");
+
+                    b.HasIndex("AnimationId", "PublishTime", "Id");
+
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
+                    b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
+
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
+                    b.ToTable("AnimationInfo", t =>
+                        {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ApplicationSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProtectedSecrets")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Revision")
+                        .IsConcurrencyToken()
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ValuesJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationSettings", t =>
+                        {
+                            t.HasCheckConstraint("CK_ApplicationSettings_Revision_Positive", "\"Revision\" > 0");
+
+                            t.HasCheckConstraint("CK_ApplicationSettings_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AuthenticationState", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ClaimId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("RegisteredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuthenticationStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_AuthenticationStates_Singleton", "\"Id\" = 1");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("MikanSubgroupId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("SeasonBangumiId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonBangumiId", "MikanSubgroupId")
+                        .IsUnique();
+
+                    b.ToTable("BangumiSubgroups");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChatConversations");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ConversationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolCallsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ToolName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConversationId");
+
+                    b.ToTable("ChatMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Feed", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feeds");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("FileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationId", "CreatedAt");
+
+                    b.HasIndex("AnimationId", "Pattern")
+                        .IsUnique();
+
+                    b.ToTable("FileNameRegexRules");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemDirectoryState", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Generation")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Path");
+
+                    b.ToTable("FileSystemDirectoryStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemDirectoryStates_Generation_Positive", "\"Generation\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Cookie")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValueSql("nextval('sdw_file_system_entry_cookie_seq')");
+
+                    b.Property<int>("DescendantFileCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("EntryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<Guid?>("FileMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDirectory")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Path");
+
+                    b.HasIndex("Cookie")
+                        .IsUnique();
+
+                    b.HasIndex("EntryId")
+                        .IsUnique();
+
+                    b.HasIndex("FileMappingId")
+                        .IsUnique()
+                        .HasFilter("\"FileMappingId\" IS NOT NULL");
+
+                    b.HasIndex("ParentPath", "Cookie");
+
+                    b.HasIndex("ParentPath", "IsDirectory", "Name")
+                        .IsDescending(false, true, false);
+
+                    b.ToTable("FileSystemEntries", t =>
+                        {
+                            t.HasCheckConstraint("CK_FileSystemEntries_NodeShape", "(\"IsDirectory\" AND \"FileMappingId\" IS NULL AND \"DescendantFileCount\" > 0) OR (NOT \"IsDirectory\" AND \"FileMappingId\" IS NOT NULL AND \"DescendantFileCount\" = 1)");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.Incident", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Detail")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("DetectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Fingerprint")
+                        .IsRequired()
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<DateTimeOffset?>("LastRetryAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRetryError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Occurrence")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SourceId")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Fingerprint")
+                        .IsUnique();
+
+                    b.HasIndex("ResolvedAt", "Type", "UpdatedAt");
+
+                    b.ToTable("Incidents", t =>
+                        {
+                            t.HasCheckConstraint("CK_Incidents_Occurrence_Positive", "\"Occurrence\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MediaLibrarySource", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsMonitoring")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("LastImportedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastRemovedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("LastScanAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("LastSkippedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastUpdatedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaLibrarySources");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("MetadataReviewMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("AppliedVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("BaseFileStore")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BaseIsDownloadFinished")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BaseStorePath")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BaseVersion")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousAiRetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousAnimationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double?>("PreviousConfidence")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid?>("PreviousCurrentOperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PreviousDescription")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("PreviousGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("PreviousIsAiProcessed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PreviousLastError")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PreviousMetadataStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("PreviousReviewedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("PreviousSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedAnimationName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationOriginalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationPosterPath")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedAnimationTmdbId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProposedDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedEpisode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProposedSeason")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("UndoneAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "AppliedVersion")
+                        .IsUnique();
+
+                    b.HasIndex("AnimationInfoId", "State");
+
+                    b.HasIndex("State", "ExpiresAt");
+
+                    b.ToTable("MetadataReviewOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_MetadataReviewOperations_Expiry", "\"ExpiresAt\" > \"CreatedAt\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MigrationExecutionState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<int>("AttemptCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Checkpoint")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("FinishedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastErrorSummary")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<DateTimeOffset?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(3);
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.HasKey("Key", "Version");
+
+                    b.ToTable("MigrationMarkers", null, t =>
+                        {
+                            t.HasCheckConstraint("CK_MigrationMarkers_AttemptCount_NonNegative", "\"AttemptCount\" >= 0");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Status_Range", "\"Status\" BETWEEN 0 AND 3");
+
+                            t.HasCheckConstraint("CK_MigrationMarkers_Version_Positive", "\"Version\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.NotificationOutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("DeduplicationKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DeepLink")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("DeliveredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset>("NextAttemptAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PayloadJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(48)
+                        .HasColumnType("character varying(48)");
+
+                    b.Property<Guid?>("WebPushSubscriptionId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeduplicationKey")
+                        .IsUnique();
+
+                    b.HasIndex("WebPushSubscriptionId");
+
+                    b.HasIndex("Status", "NextAttemptAt");
+
+                    b.ToTable("NotificationOutboxMessages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackCatalogState", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackCatalogStates_Revision_Positive", "\"Revision\" > 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("AudioTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("AutoPlayNext")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SubtitleLanguage")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("SubtitleTrackLabel")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackPreferences");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("DurationSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IsWatched")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("PositionSeconds")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("WatchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId");
+
+                    b.HasIndex("UserId", "AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "IsWatched", "UpdatedAt");
+
+                    b.ToTable("PlaybackProgresses", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Duration_NonNegative", "\"DurationSeconds\" >= 0");
+
+                            t.HasCheckConstraint("CK_PlaybackProgresses_Position_NonNegative", "\"PositionSeconds\" >= 0");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("DownloadCancellationRemoveFile")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("DownloadPreparedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DownloadSubmissionLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmissionLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmittedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ImageUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MikanId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("ScrapedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MikanId")
+                        .IsUnique();
+
+                    b.ToTable("SeasonBangumis");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("StagedFileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.Property<Guid>("FeedId")
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<string[]>("Codecs")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
+                    b.PrimitiveCollection<string[]>("ExcludedKeywords")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("Languages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<long?>("MaxSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("MinSizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.PrimitiveCollection<string[]>("Resolutions")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.PrimitiveCollection<string[]>("SubtitleGroups")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
+                    b.HasKey("FeedId");
+
+                    b.HasIndex("UpdatedAt");
+
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.TodoItemState", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTimeOffset?>("ReadAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("SnoozedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("TodoItemStates");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebDavToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("WebDavTokens");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.WebPushSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EndpointHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset?>("LastFailureAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastSuccessAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ProtectedAuth")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ProtectedEndpoint")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<string>("ProtectedP256Dh")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EndpointHash")
+                        .IsUnique();
+
+                    b.ToTable("WebPushSubscriptions");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", "AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Animation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationInfo", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", "Animation")
+                        .WithMany()
+                        .HasForeignKey("AnimationId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationGroup", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MediaLibrarySource", null)
+                        .WithMany()
+                        .HasForeignKey("MediaLibrarySourceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", null)
+                        .WithMany()
+                        .HasForeignKey("SourceFeedId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Animation");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.BangumiSubgroup", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.SeasonBangumi", "SeasonBangumi")
+                        .WithMany("Subgroups")
+                        .HasForeignKey("SeasonBangumiId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SeasonBangumi");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatMessage", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ChatConversation", "Conversation")
+                        .WithMany("Messages")
+                        .HasForeignKey("ConversationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Conversation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileNameRegexRule", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Animation", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.FileSystemEntry", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.FileMapping", "FileMapping")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.FileSystemEntry", "FileMappingId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("FileMapping");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackProgress", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "AnimationInfo")
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AnimationInfo");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
+                        .WithOne()
+                        .HasForeignKey("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", "FeedId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Feed");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ChatConversation", b =>
+                {
+                    b.Navigation("Messages");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.MetadataReviewOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
+                {
+                    b.Navigation("Subgroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.cs b/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.cs
new file mode 100644
index 0000000..0627f41
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Migrations/20260831090146_AddReleaseUpgradeSubmissionRecovery.cs
@@ -0,0 +1,167 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SecondDimensionWatcherReDive.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddReleaseUpgradeSubmissionRecovery : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "DownloadSubmissionLeaseId",
+                table: "AnimationInfo",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "DownloadSubmissionLeaseUntil",
+                table: "AnimationInfo",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "DownloadCancellationLeaseId",
+                table: "AnimationInfo",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "DownloadCancellationLeaseUntil",
+                table: "AnimationInfo",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "DownloadCancellationRemoveFile",
+                table: "AnimationInfo",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.Sql(
+                """
+                UPDATE "AnimationInfo"
+                SET "DownloadCancellationLeaseId" = gen_random_uuid(),
+                    "DownloadCancellationLeaseUntil" = clock_timestamp() + interval '3 minutes'
+                WHERE "DownloadCancellationId" IS NOT NULL
+                """);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "DownloadCancellationRemoveFile",
+                table: "ReleaseUpgradeOperations",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "DownloadPreparedAt",
+                table: "ReleaseUpgradeOperations",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "DownloadSubmissionLeaseId",
+                table: "ReleaseUpgradeOperations",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "DownloadSubmissionLeaseUntil",
+                table: "ReleaseUpgradeOperations",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "DownloadSubmittedAt",
+                table: "ReleaseUpgradeOperations",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.Sql(
+                """
+                WITH recovery AS (
+                    SELECT DISTINCT ON (operation."CandidateReleaseId")
+                        operation."Id",
+                        info."DownloadCancellationLeaseId" AS "LeaseId",
+                        info."DownloadCancellationLeaseUntil" AS "LeaseUntil"
+                    FROM "ReleaseUpgradeOperations" AS operation
+                    INNER JOIN "AnimationInfo" AS info
+                        ON info."Id" = operation."CandidateReleaseId"
+                    WHERE info."DownloadCancellationId" IS NOT NULL
+                      AND operation."Status" IN
+                          ('Downloading', 'Verifying', 'Failed', 'RolledBack', 'Completed')
+                    ORDER BY operation."CandidateReleaseId",
+                        CASE WHEN operation."Status" IN ('Downloading', 'Verifying') THEN 0 ELSE 1 END,
+                        operation."CreatedAt" DESC
+                )
+                UPDATE "ReleaseUpgradeOperations" AS operation
+                SET "Status" = CASE
+                        WHEN operation."Status" IN ('Downloading', 'Verifying') THEN 'Failed'
+                        ELSE operation."Status"
+                    END,
+                    "FailureSummary" = CASE
+                        WHEN operation."Status" IN ('Downloading', 'Verifying')
+                            THEN 'Upgrade recovery resumed a cancellation left pending during schema upgrade.'
+                        ELSE operation."FailureSummary"
+                    END,
+                    "CompletedAt" = CASE
+                        WHEN operation."Status" IN ('Downloading', 'Verifying')
+                            THEN COALESCE(operation."CompletedAt", clock_timestamp())
+                        ELSE operation."CompletedAt"
+                    END,
+                    "DownloadSubmissionLeaseId" = recovery."LeaseId",
+                    "DownloadSubmissionLeaseUntil" = recovery."LeaseUntil"
+                FROM recovery
+                WHERE operation."Id" = recovery."Id"
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "DownloadSubmissionLeaseId",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadSubmissionLeaseUntil",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadCancellationLeaseId",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadCancellationLeaseUntil",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadCancellationRemoveFile",
+                table: "AnimationInfo");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadCancellationRemoveFile",
+                table: "ReleaseUpgradeOperations");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadPreparedAt",
+                table: "ReleaseUpgradeOperations");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadSubmissionLeaseId",
+                table: "ReleaseUpgradeOperations");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadSubmissionLeaseUntil",
+                table: "ReleaseUpgradeOperations");
+
+            migrationBuilder.DropColumn(
+                name: "DownloadSubmittedAt",
+                table: "ReleaseUpgradeOperations");
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Migrations/ApplicationContextModelSnapshot.cs b/SecondDimensionWatcherReDive/Migrations/ApplicationContextModelSnapshot.cs
index 4f0d7bd..cd6adbb 100644
--- a/SecondDimensionWatcherReDive/Migrations/ApplicationContextModelSnapshot.cs
+++ b/SecondDimensionWatcherReDive/Migrations/ApplicationContextModelSnapshot.cs
@@ -51,7 +51,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Animations");
                 });
 
-
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationCatalogEntry", b =>
                 {
                     b.Property<Guid>("AnimationId")
@@ -86,12 +85,12 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("AnimationId");
 
-                    b.HasIndex("LatestPublishTime", "TmdbId")
-                        .IsDescending();
-
                     b.HasIndex("TmdbId")
                         .IsUnique();
 
+                    b.HasIndex("LatestPublishTime", "TmdbId")
+                        .IsDescending();
+
                     b.ToTable("AnimationCatalogEntries", t =>
                         {
                             t.HasCheckConstraint("CK_AnimationCatalogEntries_Counts", "\"EpisodeCount\" >= 0 AND \"ReleaseCount\" > 0 AND \"AutomationAttentionCount\" >= 0");
@@ -116,7 +115,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         });
                 });
 
-
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.AnimationGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -172,9 +170,24 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<Guid?>("DownloadAttemptId")
                         .HasColumnType("uuid");
 
+                    b.Property<Guid?>("DownloadSubmissionLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmissionLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
                     b.Property<Guid?>("DownloadCancellationId")
                         .HasColumnType("uuid");
 
+                    b.Property<Guid?>("DownloadCancellationLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadCancellationLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("DownloadCancellationRemoveFile")
+                        .HasColumnType("boolean");
+
                     b.Property<DateTimeOffset>("DownloadEndTime")
                         .HasColumnType("timestamp with time zone");
 
@@ -189,15 +202,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<string>("EnclosureId")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
                     b.Property<int?>("Episode")
                         .HasColumnType("integer");
 
+                    b.Property<int?>("ExpectedEpisodeCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FeedItemGuid")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
                     b.Property<string>("FileStore")
                         .HasColumnType("text");
 
                     b.Property<Guid?>("GroupId")
                         .HasColumnType("uuid");
 
+                    b.Property<DateTimeOffset>("IngestedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
+                    b.Property<bool>("IsActiveRelease")
+                        .HasColumnType("boolean");
+
                     b.Property<bool>("IsAiProcessed")
                         .HasColumnType("boolean");
 
@@ -207,6 +239,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<bool>("IsDownloadTracked")
                         .HasColumnType("boolean");
 
+                    b.Property<bool>("IsRetiredRelease")
+                        .HasColumnType("boolean");
+
                     b.Property<DateTimeOffset?>("MediaLibraryMissingSince")
                         .HasColumnType("timestamp with time zone");
 
@@ -229,9 +264,35 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTimeOffset>("PublishTime")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<string>("ReleaseCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ReleaseIdentity")
+                        .HasMaxLength(192)
+                        .HasColumnType("character varying(192)");
+
+                    b.PrimitiveCollection<string[]>("ReleaseLanguages")
+                        .IsRequired()
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("ReleaseResolution")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("ReleaseScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReleaseScoreReasonsJson")
+                        .HasColumnType("text");
+
                     b.Property<long?>("ReleaseSizeBytes")
                         .HasColumnType("bigint");
 
+                    b.Property<string>("ReleaseSubtitleGroup")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
                     b.Property<int?>("Season")
                         .HasColumnType("integer");
 
@@ -249,6 +310,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
+                    b.Property<string>("TorrentInfoHash")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
                     b.HasKey("Id");
 
                     b.HasIndex("CurrentMetadataReviewOperationId")
@@ -258,6 +323,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("MediaLibrarySourceId");
 
+                    b.HasIndex("ReleaseCodec");
+
+                    b.HasIndex("ReleaseIdentity")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity")
+                        .HasFilter("\"ReleaseIdentity\" IS NOT NULL");
+
+                    b.HasIndex("ReleaseResolution");
+
+                    b.HasIndex("ReleaseSubtitleGroup");
+
                     b.HasIndex("SourceFeedId");
 
                     b.HasIndex("AutomationDisposition", "PublishTime");
@@ -270,11 +346,24 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("AnimationId", "PublishTime", "Id");
 
+                    b.HasIndex("AnimationId", "Season", "Episode")
+                        .IsUnique()
+                        .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease")
+                        .HasFilter("\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL");
+
+                    b.HasIndex("DownloadType", "IsDownloadFinished", "IsDownloadTracked");
+
                     b.HasIndex("MediaLibraryMissingSince", "PublishTime", "Id");
 
+                    b.HasIndex("Season", "Episode", "ReleaseScore");
+
                     b.ToTable("AnimationInfo", t =>
                         {
+                            t.HasCheckConstraint("CK_AnimationInfo_ExpectedEpisodeCount_Positive", "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+
                             t.HasCheckConstraint("CK_AnimationInfo_MetadataConfidence_Range", "\"MetadataConfidence\" IS NULL OR (\"MetadataConfidence\" >= 0 AND \"MetadataConfidence\" <= 1)");
+
+                            t.HasCheckConstraint("CK_AnimationInfo_ReleaseScore_NonNegative", "\"ReleaseScore\" >= 0");
                         });
                 });
 
@@ -970,10 +1059,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("NotificationOutboxMessages");
                 });
 
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackCatalogState", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("Revision")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("PlaybackCatalogStates", t =>
+                        {
+                            t.HasCheckConstraint("CK_PlaybackCatalogStates_Revision_Positive", "\"Revision\" > 0");
+                        });
+                });
+
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.PlaybackPreference", b =>
                 {
                     b.Property<Guid>("UserId")
-                        .ValueGeneratedNever()
                         .HasColumnType("uuid");
 
                     b.Property<string>("AudioLanguage")
@@ -1052,6 +1156,126 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         });
                 });
 
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("OriginalMappingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId", "Kind", "OriginalMappingId")
+                        .IsUnique();
+
+                    b.ToTable("ReleaseUpgradeMappingSnapshots", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("AppliedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CandidateReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CandidateScore")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CurrentReleaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CurrentScore")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("DownloadCancellationRemoveFile")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("DownloadPreparedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DownloadSubmissionLeaseId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmissionLeaseUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DownloadSubmittedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FailureSummary")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTimeOffset?>("RollbackUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset?>("VerifiedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CandidateReleaseId")
+                        .IsUnique()
+                        .HasFilter("\"Status\" <> 'Failed'");
+
+                    b.HasIndex("CurrentReleaseId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease")
+                        .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')");
+
+                    b.HasIndex("Status", "CreatedAt");
+
+                    b.ToTable("ReleaseUpgradeOperations", t =>
+                        {
+                            t.HasCheckConstraint("CK_ReleaseUpgradeOperations_ScoreIncrease", "\"CandidateScore\" > \"CurrentScore\"");
+                        });
+                });
+
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
                 {
                     b.Property<Guid>("Id")
@@ -1082,6 +1306,39 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("SeasonBangumis");
                 });
 
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AnimationInfoId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("FileStore")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhysicalPath")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("VirtualPath")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AnimationInfoId", "VirtualPath")
+                        .IsUnique();
+
+                    b.ToTable("StagedFileMappings", t =>
+                        {
+                            t.HasCheckConstraint("CK_StagedFileMappings_VirtualPath_Canonical", "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'");
+                        });
+                });
+
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
                 {
                     b.Property<Guid>("FeedId")
@@ -1094,6 +1351,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTimeOffset>("CreatedAt")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<bool>("EnableVersionUpgrade")
+                        .HasColumnType("boolean");
+
                     b.PrimitiveCollection<string[]>("ExcludedKeywords")
                         .IsRequired()
                         .HasColumnType("text[]");
@@ -1108,6 +1368,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<long?>("MinSizeBytes")
                         .HasColumnType("bigint");
 
+                    b.Property<int>("MinimumUpgradeScore")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(25);
+
                     b.Property<string>("Mode")
                         .IsRequired()
                         .HasMaxLength(32)
@@ -1124,11 +1389,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTimeOffset>("UpdatedAt")
                         .HasColumnType("timestamp with time zone");
 
+                    b.Property<int>("UpgradeRollbackHours")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(72);
+
                     b.HasKey("FeedId");
 
                     b.HasIndex("UpdatedAt");
 
-                    b.ToTable("SubscriptionAutomationPolicies");
+                    b.ToTable("SubscriptionAutomationPolicies", t =>
+                        {
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_MinimumUpgradeScore", "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+
+                            t.HasCheckConstraint("CK_SubscriptionAutomationPolicies_UpgradeRollbackHours", "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+                        });
                 });
 
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.TodoItemState", b =>
@@ -1338,6 +1613,45 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("AnimationInfo");
                 });
 
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeMappingSnapshot", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", "Operation")
+                        .WithMany("MappingSnapshots")
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Operation");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CandidateRelease")
+                        .WithMany()
+                        .HasForeignKey("CandidateReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", "CurrentRelease")
+                        .WithMany()
+                        .HasForeignKey("CurrentReleaseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CandidateRelease");
+
+                    b.Navigation("CurrentRelease");
+                });
+
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.StagedFileMapping", b =>
+                {
+                    b.HasOne("SecondDimensionWatcherReDive.Models.AnimationInfo", null)
+                        .WithMany()
+                        .HasForeignKey("AnimationInfoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SubscriptionAutomationPolicy", b =>
                 {
                     b.HasOne("SecondDimensionWatcherReDive.Models.Feed", "Feed")
@@ -1359,6 +1673,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("MappingSnapshots");
                 });
 
+            modelBuilder.Entity("SecondDimensionWatcherReDive.Models.ReleaseUpgradeOperation", b =>
+                {
+                    b.Navigation("MappingSnapshots");
+                });
+
             modelBuilder.Entity("SecondDimensionWatcherReDive.Models.SeasonBangumi", b =>
                 {
                     b.Navigation("Subgroups");
diff --git a/SecondDimensionWatcherReDive/Models/AnimationInfo.cs b/SecondDimensionWatcherReDive/Models/AnimationInfo.cs
index 976702e..fc12770 100644
--- a/SecondDimensionWatcherReDive/Models/AnimationInfo.cs
+++ b/SecondDimensionWatcherReDive/Models/AnimationInfo.cs
@@ -5,6 +5,7 @@ namespace SecondDimensionWatcherReDive.Models;
 public class AnimationInfo
 {
     public Guid Id { get; set; }
+    public DateTimeOffset IngestedAt { get; set; } = DateTimeOffset.UtcNow;
     public string Title { get; set; } = string.Empty;
     public string Description { get; set; } = string.Empty;
 
@@ -22,8 +23,18 @@ public class AnimationInfo
 
     public Guid? DownloadAttemptId { get; set; }
 
+    public Guid? DownloadSubmissionLeaseId { get; set; }
+
+    public DateTimeOffset? DownloadSubmissionLeaseUntil { get; set; }
+
     public Guid? DownloadCancellationId { get; set; }
 
+    public Guid? DownloadCancellationLeaseId { get; set; }
+
+    public DateTimeOffset? DownloadCancellationLeaseUntil { get; set; }
+
+    public bool DownloadCancellationRemoveFile { get; set; }
+
     public DateTimeOffset DownloadStartTime { get; set; }
 
     public DateTimeOffset DownloadEndTime { get; set; }
@@ -69,4 +80,35 @@ public class AnimationInfo
     public Guid? MediaLibrarySourceId { get; set; }
 
     public DateTimeOffset? MediaLibraryMissingSince { get; set; }
+
+    public string? ReleaseIdentity { get; set; }
+
+    public string? FeedItemGuid { get; set; }
+
+    public string? EnclosureId { get; set; }
+
+    public string? TorrentInfoHash { get; set; }
+
+    public string? ReleaseSubtitleGroup { get; set; }
+
+    public string? ReleaseResolution { get; set; }
+
+    public string? ReleaseCodec { get; set; }
+
+    public string[] ReleaseLanguages { get; set; } = [];
+
+    public int ReleaseScore { get; set; }
+
+    public string? ReleaseScoreReasonsJson { get; set; }
+
+    public int? ExpectedEpisodeCount { get; set; }
+
+    public bool IsActiveRelease { get; set; }
+
+    /// <summary>
+    /// The release was deliberately removed from the live episode namespace by
+    /// a successful replacement. This remains durable after upgrade history is
+    /// deleted with either referenced release.
+    /// </summary>
+    public bool IsRetiredRelease { get; set; }
 }
diff --git a/SecondDimensionWatcherReDive/Models/ApplicationContext.cs b/SecondDimensionWatcherReDive/Models/ApplicationContext.cs
index cf4cf8d..7d50d13 100644
--- a/SecondDimensionWatcherReDive/Models/ApplicationContext.cs
+++ b/SecondDimensionWatcherReDive/Models/ApplicationContext.cs
@@ -25,6 +25,7 @@ public ApplicationContext(DbContextOptions<ApplicationContext> options)
     public DbSet<ChatConversation> ChatConversations { get; set; }
     public DbSet<ChatMessage> ChatMessages { get; set; }
     public DbSet<FileMapping> FileMappings { get; set; }
+    public DbSet<StagedFileMapping> StagedFileMappings { get; set; }
     public DbSet<FileSystemEntry> FileSystemEntries { get; set; }
     public DbSet<FileSystemDirectoryState> FileSystemDirectoryStates { get; set; }
     public DbSet<FileNameRegexRule> FileNameRegexRules { get; set; }
@@ -35,9 +36,12 @@ public ApplicationContext(DbContextOptions<ApplicationContext> options)
     public DbSet<MetadataReviewMappingSnapshot> MetadataReviewMappingSnapshots { get; set; }
     public DbSet<Incident> Incidents { get; set; }
     public DbSet<PlaybackProgress> PlaybackProgresses { get; set; }
+    public DbSet<PlaybackCatalogState> PlaybackCatalogStates { get; set; }
     public DbSet<PlaybackPreference> PlaybackPreferences { get; set; }
     public DbSet<MediaLibrarySource> MediaLibrarySources { get; set; }
     public DbSet<ApplicationSettings> ApplicationSettings { get; set; }
+    public DbSet<ReleaseUpgradeOperation> ReleaseUpgradeOperations { get; set; }
+    public DbSet<ReleaseUpgradeMappingSnapshot> ReleaseUpgradeMappingSnapshots { get; set; }
     public DbSet<NotificationOutboxMessage> NotificationOutboxMessages { get; set; }
     public DbSet<TodoItemState> TodoItemStates { get; set; }
     public DbSet<WebPushSubscription> WebPushSubscriptions { get; set; }
@@ -219,6 +223,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             .Property(info => info.StateVersion)
             .IsConcurrencyToken();
 
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.IngestedAt)
+            .HasDefaultValueSql("CURRENT_TIMESTAMP");
+
         modelBuilder.Entity<AnimationInfo>()
             .Property(info => info.MetadataLastError)
             .HasMaxLength(1024);
@@ -231,6 +239,71 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<AnimationInfo>()
             .HasIndex(info => new { info.MetadataStatus, info.PublishTime });
 
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => info.ReleaseIdentity)
+            .IsUnique()
+            .HasFilter("\"ReleaseIdentity\" IS NOT NULL")
+            .HasDatabaseName("UX_AnimationInfo_ReleaseIdentity");
+
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => new { info.Season, info.Episode, info.ReleaseScore });
+
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => info.ReleaseSubtitleGroup);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => info.ReleaseResolution);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => info.ReleaseCodec);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex(info => new
+            {
+                info.DownloadType,
+                info.IsDownloadFinished,
+                info.IsDownloadTracked
+            });
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.ReleaseIdentity)
+            .HasMaxLength(192);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.FeedItemGuid)
+            .HasMaxLength(1024);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.EnclosureId)
+            .HasMaxLength(2048);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.TorrentInfoHash)
+            .HasMaxLength(64);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.ReleaseSubtitleGroup)
+            .HasMaxLength(256);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.ReleaseResolution)
+            .HasMaxLength(32);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .Property(info => info.ReleaseCodec)
+            .HasMaxLength(32);
+
+        modelBuilder.Entity<AnimationInfo>()
+            .ToTable(table =>
+            {
+                table.HasCheckConstraint(
+                    "CK_AnimationInfo_ReleaseScore_NonNegative",
+                    "\"ReleaseScore\" >= 0");
+                table.HasCheckConstraint(
+                    "CK_AnimationInfo_ExpectedEpisodeCount_Positive",
+                    "\"ExpectedEpisodeCount\" IS NULL OR \"ExpectedEpisodeCount\" > 0");
+            });
+
         modelBuilder.Entity<AnimationInfo>()
             .HasIndex("AnimationId", "PublishTime", "Id");
 
@@ -394,6 +467,18 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                     "\"DurationSeconds\" >= 0");
             });
 
+        modelBuilder.Entity<PlaybackCatalogState>()
+            .HasKey(state => state.UserId);
+
+        modelBuilder.Entity<PlaybackCatalogState>()
+            .Property(state => state.UserId)
+            .ValueGeneratedNever();
+
+        modelBuilder.Entity<PlaybackCatalogState>()
+            .ToTable(table => table.HasCheckConstraint(
+                "CK_PlaybackCatalogStates_Revision_Positive",
+                "\"Revision\" > 0"));
+
         modelBuilder.Entity<PlaybackPreference>()
             .HasKey(preference => preference.UserId);
 
@@ -433,6 +518,25 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                 "CK_FileMappings_VirtualPath_Canonical",
                 "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'"));
 
+        modelBuilder.Entity<StagedFileMapping>()
+            .HasIndex(mapping => new { mapping.AnimationInfoId, mapping.VirtualPath })
+            .IsUnique();
+
+        modelBuilder.Entity<StagedFileMapping>()
+            .Property(mapping => mapping.VirtualPath)
+            .HasMaxLength(2048);
+
+        modelBuilder.Entity<StagedFileMapping>()
+            .HasOne<AnimationInfo>()
+            .WithMany()
+            .HasForeignKey(mapping => mapping.AnimationInfoId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        modelBuilder.Entity<StagedFileMapping>()
+            .ToTable(table => table.HasCheckConstraint(
+                "CK_StagedFileMappings_VirtualPath_Canonical",
+                "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'"));
+
         modelBuilder.Entity<MetadataReviewMappingSnapshot>()
             .ToTable(table => table.HasCheckConstraint(
                 "CK_MetadataReviewMappingSnapshots_VirtualPath_Canonical",
@@ -523,6 +627,14 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<AnimationInfo>()
             .HasIndex(info => info.SourceFeedId);
 
+        modelBuilder.Entity<AnimationInfo>()
+            .HasIndex("AnimationId", "Season", "Episode")
+            .IsUnique()
+            .HasFilter(
+                "\"IsActiveRelease\" = TRUE AND \"AnimationId\" IS NOT NULL " +
+                "AND \"Season\" IS NOT NULL AND \"Episode\" IS NOT NULL")
+            .HasDatabaseName("UX_AnimationInfo_ActiveEpisodeRelease");
+
         modelBuilder.Entity<SubscriptionAutomationPolicy>()
             .HasKey(policy => policy.FeedId);
 
@@ -540,6 +652,89 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<SubscriptionAutomationPolicy>()
             .HasIndex(policy => policy.UpdatedAt);
 
+        modelBuilder.Entity<SubscriptionAutomationPolicy>()
+            .Property(policy => policy.MinimumUpgradeScore)
+            .HasDefaultValue(25);
+
+        modelBuilder.Entity<SubscriptionAutomationPolicy>()
+            .Property(policy => policy.UpgradeRollbackHours)
+            .HasDefaultValue(72);
+
+        modelBuilder.Entity<SubscriptionAutomationPolicy>()
+            .ToTable(table =>
+            {
+                table.HasCheckConstraint(
+                    "CK_SubscriptionAutomationPolicies_MinimumUpgradeScore",
+                    "\"MinimumUpgradeScore\" >= 1 AND \"MinimumUpgradeScore\" <= 1000");
+                table.HasCheckConstraint(
+                    "CK_SubscriptionAutomationPolicies_UpgradeRollbackHours",
+                    "\"UpgradeRollbackHours\" >= 1 AND \"UpgradeRollbackHours\" <= 720");
+            });
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .Property(operation => operation.Status)
+            .HasConversion<string>()
+            .HasMaxLength(32);
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .Property(operation => operation.FailureSummary)
+            .HasMaxLength(2048);
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .HasOne(operation => operation.CurrentRelease)
+            .WithMany()
+            .HasForeignKey(operation => operation.CurrentReleaseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .HasOne(operation => operation.CandidateRelease)
+            .WithMany()
+            .HasForeignKey(operation => operation.CandidateReleaseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .HasIndex(operation => operation.CandidateReleaseId)
+            .IsUnique()
+            .HasFilter("\"Status\" <> 'Failed'");
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .HasIndex(operation => operation.CurrentReleaseId)
+            .IsUnique()
+            .HasFilter("\"Status\" IN ('Downloading', 'Verifying', 'Applied')")
+            .HasDatabaseName("UX_ReleaseUpgradeOperations_ActiveCurrentRelease");
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .HasIndex(operation => new { operation.Status, operation.CreatedAt });
+
+        modelBuilder.Entity<ReleaseUpgradeOperation>()
+            .ToTable(table => table.HasCheckConstraint(
+                "CK_ReleaseUpgradeOperations_ScoreIncrease",
+                "\"CandidateScore\" > \"CurrentScore\""));
+
+        modelBuilder.Entity<ReleaseUpgradeMappingSnapshot>()
+            .Property(snapshot => snapshot.Kind)
+            .HasConversion<string>()
+            .HasMaxLength(32);
+
+        modelBuilder.Entity<ReleaseUpgradeMappingSnapshot>()
+            .Property(snapshot => snapshot.VirtualPath)
+            .HasMaxLength(2048);
+
+        modelBuilder.Entity<ReleaseUpgradeMappingSnapshot>()
+            .HasOne(snapshot => snapshot.Operation)
+            .WithMany(operation => operation.MappingSnapshots)
+            .HasForeignKey(snapshot => snapshot.OperationId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        modelBuilder.Entity<ReleaseUpgradeMappingSnapshot>()
+            .HasIndex(snapshot => new { snapshot.OperationId, snapshot.Kind, snapshot.OriginalMappingId })
+            .IsUnique();
+
+        modelBuilder.Entity<ReleaseUpgradeMappingSnapshot>()
+            .ToTable(table => table.HasCheckConstraint(
+                "CK_ReleaseUpgradeMappingSnapshots_VirtualPath_Canonical",
+                "\"VirtualPath\" ~ '^/[^/]+(?:/[^/]+)*$' AND \"VirtualPath\" !~ '(^|/)\\.\\.?($|/)'"));
+
         modelBuilder.Entity<BangumiSubgroup>()
             .HasIndex(s => new { s.SeasonBangumiId, s.MikanSubgroupId })
             .IsUnique();
diff --git a/SecondDimensionWatcherReDive/Models/PlaybackCatalogState.cs b/SecondDimensionWatcherReDive/Models/PlaybackCatalogState.cs
new file mode 100644
index 0000000..65d435e
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Models/PlaybackCatalogState.cs
@@ -0,0 +1,7 @@
+namespace SecondDimensionWatcherReDive.Models;
+
+public sealed class PlaybackCatalogState
+{
+    public Guid UserId { get; set; }
+    public long Revision { get; set; }
+}
diff --git a/SecondDimensionWatcherReDive/Models/ReleaseUpgradeOperation.cs b/SecondDimensionWatcherReDive/Models/ReleaseUpgradeOperation.cs
new file mode 100644
index 0000000..b1e9e7a
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Models/ReleaseUpgradeOperation.cs
@@ -0,0 +1,40 @@
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+
+namespace SecondDimensionWatcherReDive.Models;
+
+public class ReleaseUpgradeOperation
+{
+    public Guid Id { get; set; }
+    public Guid CurrentReleaseId { get; set; }
+    public AnimationInfo CurrentRelease { get; set; } = null!;
+    public Guid CandidateReleaseId { get; set; }
+    public AnimationInfo CandidateRelease { get; set; } = null!;
+    public ReleaseUpgradeStatus Status { get; set; }
+    public int CurrentScore { get; set; }
+    public int CandidateScore { get; set; }
+    public DateTimeOffset CreatedAt { get; set; }
+    public DateTimeOffset? VerifiedAt { get; set; }
+    public DateTimeOffset? AppliedAt { get; set; }
+    public DateTimeOffset? RollbackUntil { get; set; }
+    public DateTimeOffset? CompletedAt { get; set; }
+    public string? FailureSummary { get; set; }
+    public DateTimeOffset? DownloadPreparedAt { get; set; }
+    public DateTimeOffset? DownloadSubmittedAt { get; set; }
+    public Guid? DownloadSubmissionLeaseId { get; set; }
+    public DateTimeOffset? DownloadSubmissionLeaseUntil { get; set; }
+    public bool DownloadCancellationRemoveFile { get; set; }
+    public ICollection<ReleaseUpgradeMappingSnapshot> MappingSnapshots { get; set; } = [];
+}
+
+public class ReleaseUpgradeMappingSnapshot
+{
+    public Guid Id { get; set; }
+    public Guid OperationId { get; set; }
+    public ReleaseUpgradeOperation Operation { get; set; } = null!;
+    public ReleaseUpgradeMappingKind Kind { get; set; }
+    public Guid OriginalMappingId { get; set; }
+    public Guid AnimationInfoId { get; set; }
+    public string VirtualPath { get; set; } = string.Empty;
+    public string PhysicalPath { get; set; } = string.Empty;
+    public string FileStore { get; set; } = string.Empty;
+}
diff --git a/SecondDimensionWatcherReDive/Models/StagedFileMapping.cs b/SecondDimensionWatcherReDive/Models/StagedFileMapping.cs
new file mode 100644
index 0000000..57fe3e7
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Models/StagedFileMapping.cs
@@ -0,0 +1,14 @@
+namespace SecondDimensionWatcherReDive.Models;
+
+/// <summary>
+/// A completed alternative release's files before the release is validated and
+/// atomically promoted into the live virtual-file-system namespace.
+/// </summary>
+public sealed class StagedFileMapping
+{
+    public Guid Id { get; set; }
+    public Guid AnimationInfoId { get; set; }
+    public string VirtualPath { get; set; } = string.Empty;
+    public string PhysicalPath { get; set; } = string.Empty;
+    public string FileStore { get; set; } = string.Empty;
+}
diff --git a/SecondDimensionWatcherReDive/Models/SubscriptionAutomationPolicy.cs b/SecondDimensionWatcherReDive/Models/SubscriptionAutomationPolicy.cs
index aec6c49..472d4bf 100644
--- a/SecondDimensionWatcherReDive/Models/SubscriptionAutomationPolicy.cs
+++ b/SecondDimensionWatcherReDive/Models/SubscriptionAutomationPolicy.cs
@@ -27,4 +27,10 @@ public class SubscriptionAutomationPolicy
     public DateTimeOffset CreatedAt { get; set; }
 
     public DateTimeOffset UpdatedAt { get; set; }
+
+    public bool EnableVersionUpgrade { get; set; }
+
+    public int MinimumUpgradeScore { get; set; } = 25;
+
+    public int UpgradeRollbackHours { get; set; } = 72;
 }
diff --git a/SecondDimensionWatcherReDive/Program.cs b/SecondDimensionWatcherReDive/Program.cs
index 4c46a90..3a220de 100644
--- a/SecondDimensionWatcherReDive/Program.cs
+++ b/SecondDimensionWatcherReDive/Program.cs
@@ -41,6 +41,7 @@
 using SecondDimensionWatcherReDive.Utils.FileStore;
 using SecondDimensionWatcherReDive.Utils.MetadataReview;
 using SecondDimensionWatcherReDive.Utils.Incidents;
+using SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
 using SecondDimensionWatcherReDive.Utils.Notifications;
 using SecondDimensionWatcherReDive.Utils.Http;
 using SecondDimensionWatcherReDive.Utils.Scraper;
@@ -489,6 +490,7 @@ void ConfigureFeedClient(HttpClient client)
 builder.Services.AddSingleton<IMediaLibraryScanQueue>(sp =>
     sp.GetRequiredService<MediaLibraryScanQueue>());
 builder.Services.AddHostedService<MediaLibraryScanBackgroundService>();
+builder.Services.AddHostedService<ReleaseUpgradeBackgroundService>();
 
 //Add scheduled tasks
 builder.Services.AddSingleton<SyncFeed>();
@@ -523,6 +525,7 @@ void ConfigureFeedClient(HttpClient client)
 builder.Services.AddSingleton<ISubscriptionFeedReader, MikananiSubscriptionFeedReader>();
 builder.Services.AddSingleton<ISubscriptionReleaseMetadataExtractor, SubscriptionReleaseMetadataExtractor>();
 builder.Services.AddSingleton<ISubscriptionAutomationMatcher, SubscriptionAutomationMatcher>();
+builder.Services.AddSingleton<IReleaseScoringService, ReleaseScoringService>();
 builder.Services.AddScoped<ISubscriptionAutomationSimulationService, SubscriptionAutomationSimulationService>();
 builder.Services.AddTransient<IFeedService, MikananiFeedService>();
 
@@ -544,6 +547,8 @@ void ConfigureFeedClient(HttpClient client)
 builder.Services.AddScoped<IPlaybackRepository, PlaybackRepository>();
 builder.Services.AddScoped<IIncidentRepository, IncidentRepository>();
 builder.Services.AddScoped<IMediaLibrarySourceRepository, MediaLibrarySourceRepository>();
+builder.Services.AddScoped<ILibrarySearchRepository, LibrarySearchRepository>();
+builder.Services.AddScoped<IReleaseUpgradeRepository, ReleaseUpgradeRepository>();
 builder.Services.AddScoped<INotificationOutboxRepository, NotificationOutboxRepository>();
 builder.Services.AddScoped<IWebPushSubscriptionRepository, WebPushSubscriptionRepository>();
 builder.Services.AddScoped<ITodoRepository, TodoRepository>();
@@ -552,6 +557,7 @@ void ConfigureFeedClient(HttpClient client)
 builder.Services.AddSingleton<ISeasonScraper, MikananiSeasonScraper>();
 builder.Services.AddScoped<IMetadataReviewService, MetadataReviewService>();
 builder.Services.AddScoped<IIncidentRetryService, IncidentRetryService>();
+builder.Services.AddScoped<IReleaseUpgradeCoordinator, ReleaseUpgradeCoordinator>();
 
 //Add AI Inference
 // Register all engines even when initially unconfigured. Runtime settings can then enable or
diff --git a/SecondDimensionWatcherReDive/Repositories/AnimationInfoRepository.cs b/SecondDimensionWatcherReDive/Repositories/AnimationInfoRepository.cs
index 8e42b65..be5c5d2 100644
--- a/SecondDimensionWatcherReDive/Repositories/AnimationInfoRepository.cs
+++ b/SecondDimensionWatcherReDive/Repositories/AnimationInfoRepository.cs
@@ -1,6 +1,7 @@
 using System.Runtime.CompilerServices;
 using System.Data;
 using Microsoft.EntityFrameworkCore;
+using Npgsql;
 using SecondDimensionWatcherReDive.Framework.DataRepository;
 using SecondDimensionWatcherReDive.Framework.FileDownload;
 
@@ -319,6 +320,7 @@ public async Task<IReadOnlyList<AnimationInfo>> GetDownloadedMigrationBatchAsync
     public async Task<AnimationInfo?> FindByIdWithAnimationAsync(Guid id, CancellationToken cancellationToken)
     {
         var entity = await context.AnimationInfo
+            .AsNoTracking()
             .Include(a => a.Animation)
             .Include(a => a.Group)
             .FirstOrDefaultAsync(a => a.Id == id, cancellationToken);
@@ -443,7 +445,44 @@ public async Task<bool> RemoveMediaLibraryEntryAsync(
                 || entity.MediaLibrarySourceId != expectedSourceId
                 || entity.DownloadType != FileDownloadTypes.MediaLibraryImport)
                 return false;
-
+            if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation =>
+                        (operation.CurrentReleaseId == entity.Id ||
+                         operation.CandidateReleaseId == entity.Id) &&
+                        operation.DownloadSubmissionLeaseId != null,
+                    cancellationToken))
+                return false;
+            var previousEpisodeIdentity = GetEpisodeIdentity(writeContext, entity);
+            var wasActiveRelease = entity.IsActiveRelease;
+            if (!wasActiveRelease)
+            {
+                await CollapseReleaseUpgradeLineageBeforeDeleteAsync(
+                    writeContext,
+                    entity,
+                    cancellationToken);
+            }
+            var previousMappings = await writeContext.FileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == entity.Id)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
+            entity.IsActiveRelease = false;
+            entity.StateVersion = checked(entity.StateVersion + 1);
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await PromotePreviousEpisodeSuccessorAsync(
+                writeContext,
+                entity.Id,
+                wasActiveRelease,
+                previousEpisodeIdentity,
+                currentIdentity: null,
+                previousMappings,
+                retainChangedReleaseMappings: false,
+                cancellationToken);
+            var operationsToDelete = await writeContext.ReleaseUpgradeOperations
+                .Where(operation => operation.CurrentReleaseId == entity.Id ||
+                                    operation.CandidateReleaseId == entity.Id)
+                .ToListAsync(cancellationToken);
+            writeContext.ReleaseUpgradeOperations.RemoveRange(operationsToDelete);
             await writeContext.FileMappings
                 .Where(mapping => mapping.AnimationInfoId == id)
                 .ExecuteDeleteAsync(cancellationToken);
@@ -454,6 +493,150 @@ await writeContext.FileMappings
         });
     }
 
+    private static async Task CollapseReleaseUpgradeLineageBeforeDeleteAsync(
+        Models.ApplicationContext writeContext,
+        Models.AnimationInfo removedRelease,
+        CancellationToken cancellationToken)
+    {
+        var databaseNow = await writeContext.Database
+            .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+            .SingleAsync(cancellationToken);
+        var incomingActiveOperations = await writeContext.ReleaseUpgradeOperations
+            .Where(operation =>
+                operation.CandidateReleaseId == removedRelease.Id &&
+                (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                 operation.Status == ReleaseUpgradeStatus.Verifying ||
+                 operation.Status == ReleaseUpgradeStatus.Applied))
+            .ToListAsync(cancellationToken);
+        foreach (var operation in incomingActiveOperations)
+        {
+            if (operation.Status == ReleaseUpgradeStatus.Applied)
+            {
+                operation.Status = ReleaseUpgradeStatus.Completed;
+            }
+            else
+            {
+                operation.Status = ReleaseUpgradeStatus.Failed;
+                operation.FailureSummary =
+                    "Upgrade was superseded because its candidate was removed from the media library.";
+            }
+            operation.CompletedAt ??= databaseNow;
+        }
+        if (incomingActiveOperations.Count > 0)
+            await writeContext.SaveChangesAsync(cancellationToken);
+
+        var lineages = await GetAncestorLineagesAsync(
+            writeContext,
+            removedRelease.Id,
+            cancellationToken);
+        if (lineages.Count == 0)
+            return;
+
+        var ancestorIds = lineages.Keys.ToArray();
+        var existingAncestors = await writeContext.AnimationInfo
+            .AsNoTracking()
+            .Where(info => ancestorIds.Contains(info.Id))
+            .Select(info => info.Id)
+            .ToListAsync(cancellationToken);
+        var existingIds = existingAncestors.ToHashSet();
+        if (existingIds.Count == 0)
+            return;
+
+        var occupiedActiveCurrentIds = await writeContext.ReleaseUpgradeOperations
+            .AsNoTracking()
+            .Where(operation =>
+                ancestorIds.Contains(operation.CurrentReleaseId) &&
+                (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                 operation.Status == ReleaseUpgradeStatus.Verifying ||
+                 operation.Status == ReleaseUpgradeStatus.Applied))
+            .Select(operation => operation.CurrentReleaseId)
+            .ToListAsync(cancellationToken);
+        var occupiedIds = occupiedActiveCurrentIds.ToHashSet();
+
+        var outgoingOperations = await writeContext.ReleaseUpgradeOperations
+            .Include(operation => operation.MappingSnapshots)
+            .Where(operation =>
+                operation.CurrentReleaseId == removedRelease.Id &&
+                (operation.Status == ReleaseUpgradeStatus.Applied ||
+                 operation.Status == ReleaseUpgradeStatus.Completed))
+            .ToListAsync(cancellationToken);
+        foreach (var operation in outgoingOperations)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            // Compose the historical edges structurally. Release metadata and
+            // availability are mutable, while the operation snapshots are the
+            // durable account of the upgrade. Later promotion/rollback still
+            // performs its own current eligibility and episode checks.
+            var structuralAncestors = lineages
+                .Where(pair => existingIds.Contains(pair.Key) &&
+                               pair.Key != operation.CandidateReleaseId)
+                .OrderBy(pair => pair.Value.Depth)
+                .ToList();
+            var selected = structuralAncestors
+                .Where(pair => operation.Status != ReleaseUpgradeStatus.Applied ||
+                               !occupiedIds.Contains(pair.Key))
+                .Select(pair => new
+                {
+                    ReleaseId = pair.Key,
+                    Lineage = pair.Value
+                })
+                .FirstOrDefault();
+            if (selected is null && operation.Status == ReleaseUpgradeStatus.Applied)
+            {
+                if (structuralAncestors.Count > 0)
+                {
+                    var fallback = structuralAncestors[0];
+                    operation.Status = ReleaseUpgradeStatus.Completed;
+                    operation.CompletedAt ??= databaseNow;
+                    selected = new
+                    {
+                        ReleaseId = fallback.Key,
+                        Lineage = fallback.Value
+                    };
+                }
+            }
+            if (selected is null)
+                continue;
+
+            var previousSnapshots = operation.MappingSnapshots
+                .Where(snapshot => snapshot.Kind == ReleaseUpgradeMappingKind.Previous)
+                .ToList();
+            writeContext.ReleaseUpgradeMappingSnapshots.RemoveRange(previousSnapshots);
+            await writeContext.ReleaseUpgradeMappingSnapshots.AddRangeAsync(
+                selected.Lineage.PreviousMappings.Select(mapping =>
+                    new Models.ReleaseUpgradeMappingSnapshot
+                    {
+                        Id = Guid.NewGuid(),
+                        OperationId = operation.Id,
+                        Kind = ReleaseUpgradeMappingKind.Previous,
+                        OriginalMappingId = mapping.Id,
+                        AnimationInfoId = selected.ReleaseId,
+                        VirtualPath = mapping.VirtualPath,
+                        PhysicalPath = mapping.PhysicalPath,
+                        FileStore = mapping.FileStore
+                    }),
+                cancellationToken);
+            operation.CurrentReleaseId = selected.ReleaseId;
+            operation.CurrentScore = selected.Lineage.HistoricalScore;
+
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"""
+                 DELETE FROM "ReleaseUpgradeEntryIdentitySnapshots"
+                 WHERE "OperationId" = {operation.Id}
+                 """,
+                cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"""
+                 INSERT INTO "ReleaseUpgradeEntryIdentitySnapshots"
+                     ("OperationId", "Path", "EntryId", "IsDirectory")
+                 SELECT {operation.Id}, "Path", "EntryId", "IsDirectory"
+                 FROM "ReleaseUpgradeEntryIdentitySnapshots"
+                 WHERE "OperationId" = {selected.Lineage.SourceOperationId}
+                 """,
+                cancellationToken);
+        }
+    }
+
     public async IAsyncEnumerable<AnimationInfo> GetUnfinishedTorrentDownloadsAsync(
         [EnumeratorCancellation] CancellationToken cancellationToken)
     {
@@ -471,6 +654,9 @@ public async IAsyncEnumerable<AnimationInfo> GetUnfinishedTorrentDownloadsAsync(
     public async Task<IReadOnlyList<AnimationInfo>> GetPendingInferenceAsync(int maxRetryCount, CancellationToken cancellationToken)
     {
         var entities = await context.AnimationInfo
+            .AsNoTracking()
+            .Include(info => info.Animation)
+            .Include(info => info.Group)
             .Where(i => !i.IsAiProcessed
                         && i.AiRetryCount < maxRetryCount
                         && i.MediaLibraryMissingSince == null
@@ -506,7 +692,12 @@ public async Task<IReadOnlyList<AnimationInfo>> GetDownloadedWithoutFileMappings
                            && info.MediaLibraryMissingSince == null
                            && info.FileStore != null
                            && info.StorePath != null
-                           && !context.FileMappings.Any(mapping => mapping.AnimationInfoId == info.Id))
+                           && !context.FileMappings.Any(mapping => mapping.AnimationInfoId == info.Id)
+                           && !context.StagedFileMappings.Any(mapping => mapping.AnimationInfoId == info.Id)
+                           // A retired incumbent intentionally owns no live/staged
+                           // mappings. Keep active releases in the sweep even if a
+                           // stale marker survives an interrupted lifecycle change.
+                           && (info.IsActiveRelease || !info.IsRetiredRelease))
             .OrderBy(info => info.DownloadEndTime)
             .ToListAsync(cancellationToken);
         return entities.Select(entity => entity.ToRecord()).ToList();
@@ -519,43 +710,258 @@ public async Task<IReadOnlyList<AnimationInfo>> GetDownloadedWithoutFileMappings
         return entity?.ToRecord();
     }
 
+    public Task<bool> ExistsReleaseSourceAsync(
+        Guid? sourceFeedId,
+        string? feedItemGuid,
+        string? enclosureId,
+        string downloadUrl,
+        CancellationToken cancellationToken)
+    {
+        var normalizedGuid = NormalizeExternalReleaseId(feedItemGuid);
+        var normalizedEnclosure = NormalizeExternalReleaseId(enclosureId);
+        var normalizedUrl = downloadUrl.Trim();
+        return context.AnimationInfo.AsNoTracking().AnyAsync(info =>
+                info.DownloadUrl == normalizedUrl ||
+                (normalizedGuid != null &&
+                 info.SourceFeedId == sourceFeedId &&
+                 info.FeedItemGuid == normalizedGuid) ||
+                (normalizedEnclosure != null &&
+                 info.SourceFeedId == sourceFeedId &&
+                 info.EnclosureId == normalizedEnclosure),
+            cancellationToken);
+    }
+
     public async Task AddAsync(AnimationInfo info, CancellationToken cancellationToken)
     {
-        await context.AnimationInfo.AddAsync(info.ToEntity(), cancellationToken);
-        await context.SaveChangesAsync(cancellationToken);
+        var entity = info.ToEntity();
+        await context.AnimationInfo.AddAsync(entity, cancellationToken);
+        try
+        {
+            await context.SaveChangesAsync(cancellationToken);
+        }
+        catch (DbUpdateException exception) when (exception.InnerException is PostgresException
+        {
+            SqlState: PostgresErrorCodes.UniqueViolation,
+            ConstraintName: "UX_AnimationInfo_ReleaseIdentity"
+        } && !string.IsNullOrWhiteSpace(info.ReleaseIdentity))
+        {
+            context.Entry(entity).State = EntityState.Detached;
+            throw new DuplicateReleaseException(info.ReleaseIdentity, exception);
+        }
     }
 
     public async Task UpdateAsync(AnimationInfo info, CancellationToken cancellationToken)
     {
-        var entity = await context.AnimationInfo.FindAsync([info.Id], cancellationToken)
-                     ?? throw new InvalidOperationException($"AnimationInfo {info.Id} not found");
-        var currentStateVersion = entity.StateVersion;
-        if (currentStateVersion != info.StateVersion)
-            throw new DbUpdateConcurrencyException(
-                $"AnimationInfo {info.Id} changed from revision {info.StateVersion} to {currentStateVersion}.");
-
-        await ResetTodoStateForTransitionAsync(
-            context,
-            entity,
-            info.MetadataStatus,
-            info.AutomationDisposition,
+        var strategy = context.Database.CreateExecutionStrategy();
+        await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database
+                .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var entity = await MappingTransactionLock.LockAnimationInfoAsync(
+                             writeContext,
+                             info.Id,
+                             cancellationToken)
+                         ?? throw new InvalidOperationException($"AnimationInfo {info.Id} not found");
+            var currentStateVersion = entity.StateVersion;
+            if (currentStateVersion != info.StateVersion)
+                throw new DbUpdateConcurrencyException(
+                    $"AnimationInfo {info.Id} changed from revision {info.StateVersion} to {currentStateVersion}.");
+            var previousEpisodeIdentity = GetEpisodeIdentity(writeContext, entity);
+            var wasActiveRelease = entity.IsActiveRelease;
+            var previousMappings = await writeContext.FileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == entity.Id)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
+            var previousMappingIdentities = await FileMappingSetReconciler.CaptureIdentitiesAsync(
+                writeContext,
+                previousMappings,
+                cancellationToken);
+
+            await ResetTodoStateForTransitionAsync(
+                writeContext,
+                entity,
+                info.MetadataStatus,
+                info.AutomationDisposition,
+                cancellationToken);
+            info.ApplyTo(entity);
+            entity.Animation = info.Animation is null
+                ? null
+                : await writeContext.Animations.FindAsync([info.Animation.Id], cancellationToken);
+            entity.Group = info.Group is null
+                ? null
+                : await writeContext.AnimationGroups.FindAsync([info.Group.Id], cancellationToken);
+            writeContext.Entry(entity).Property<Guid?>("AnimationId").CurrentValue = info.Animation?.Id;
+            writeContext.Entry(entity).Property<Guid?>("GroupId").CurrentValue = info.Group?.Id;
+            await SetEpisodeReleaseActivityAsync(
+                writeContext,
+                entity,
+                willHaveMappings: false,
+                cancellationToken);
+            await ReconcileMappingVisibilityAfterMetadataChangeAsync(
+                writeContext,
+                entity,
+                cancellationToken);
+            var currentEpisodeIdentity = entity.IsActiveRelease
+                ? GetEpisodeIdentity(writeContext, entity)
+                : null;
+            entity.StateVersion = checked(currentStateVersion + 1);
+
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await PromotePreviousEpisodeSuccessorAsync(
+                writeContext,
+                entity.Id,
+                wasActiveRelease,
+                previousEpisodeIdentity,
+                currentEpisodeIdentity,
+                previousMappings,
+                retainChangedReleaseMappings: true,
+                cancellationToken);
+            await previousMappingIdentities.RestoreEntryIdentitiesAsync(
+                writeContext,
+                cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+        });
+    }
+
+    public async Task<DownloadSubmissionLease?> TryStartDownloadAsync(
+        Guid id,
+        Guid downloadAttemptId,
+        Guid submissionLeaseId,
+        TimeSpan submissionLeaseDuration,
+        DateTimeOffset startedAt,
+        SubscriptionAutomationDisposition? queuedDisposition,
+        CancellationToken cancellationToken)
+    {
+        if (submissionLeaseDuration <= TimeSpan.Zero ||
+            submissionLeaseDuration > TimeSpan.FromMinutes(30))
+            throw new ArgumentOutOfRangeException(nameof(submissionLeaseDuration));
+
+        var result = await TryStartDownloadCoreAsync(
+            id,
+            releaseUpgradeOperationId: null,
+            downloadAttemptId,
+            submissionLeaseId,
+            submissionLeaseDuration,
+            startedAt,
+            queuedDisposition,
             cancellationToken);
-        info.ApplyTo(entity);
+        return result.IsSuccess && result.SubmissionLeaseUntil is { } leaseUntil
+            ? new DownloadSubmissionLease(submissionLeaseId, leaseUntil)
+            : null;
+    }
+
+    public async Task<bool> TryMarkDownloadSubmittedAsync(
+        Guid id,
+        Guid downloadAttemptId,
+        Guid submissionLeaseId,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database
+                .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var entity = await MappingTransactionLock.LockAnimationInfoAsync(
+                writeContext,
+                id,
+                cancellationToken);
+            if (entity is null ||
+                !entity.IsDownloadTracked ||
+                entity.DownloadAttemptId != downloadAttemptId ||
+                entity.DownloadCancellationId is not null)
+                return false;
+
+            if (entity.DownloadSubmissionLeaseId is null)
+            {
+                await transaction.CommitAsync(cancellationToken);
+                return true;
+            }
+
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            if (entity.DownloadSubmissionLeaseId != submissionLeaseId ||
+                entity.DownloadSubmissionLeaseUntil <= databaseNow)
+                return false;
+
+            entity.DownloadSubmissionLeaseId = null;
+            entity.DownloadSubmissionLeaseUntil = null;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return true;
+        });
+    }
 
-        entity.Animation = info.Animation is null
-            ? null
-            : await context.Animations.FindAsync([info.Animation.Id], cancellationToken);
-        entity.Group = info.Group is null
-            ? null
-            : await context.AnimationGroups.FindAsync([info.Group.Id], cancellationToken);
-        entity.StateVersion = checked(currentStateVersion + 1);
+    public async Task<IReadOnlyList<PendingDownloadSubmission>> GetPendingDownloadSubmissionsAsync(
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200)
+            throw new ArgumentOutOfRangeException(nameof(take));
+
+        var databaseNow = await context.Database
+            .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+            .SingleAsync(cancellationToken);
+        return await context.AnimationInfo
+            .AsNoTracking()
+            .Where(info =>
+                info.IsDownloadTracked &&
+                !info.IsDownloadFinished &&
+                info.DownloadAttemptId != null &&
+                info.DownloadCancellationId == null &&
+                info.DownloadSubmissionLeaseId != null &&
+                (info.DownloadSubmissionLeaseUntil == null ||
+                 info.DownloadSubmissionLeaseUntil <= databaseNow) &&
+                !context.ReleaseUpgradeOperations.Any(operation =>
+                    operation.CandidateReleaseId == info.Id &&
+                    (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                     operation.Status == ReleaseUpgradeStatus.Verifying)))
+            .OrderBy(info => info.DownloadSubmissionLeaseUntil)
+            .ThenBy(info => info.DownloadStartTime)
+            .ThenBy(info => info.Id)
+            .Select(info => new PendingDownloadSubmission(
+                info.Id,
+                info.DownloadAttemptId!.Value,
+                info.DownloadSubmissionLeaseId!.Value))
+            .Take(take)
+            .ToListAsync(cancellationToken);
+    }
 
-        await context.SaveChangesAsync(cancellationToken);
+    public async Task<bool> TryStartUpgradeDownloadAsync(
+        Guid id,
+        Guid releaseUpgradeOperationId,
+        Guid downloadAttemptId,
+        DateTimeOffset startedAt,
+        SubscriptionAutomationDisposition? queuedDisposition,
+        CancellationToken cancellationToken)
+    {
+        var result = await TryStartDownloadCoreAsync(
+            id,
+            releaseUpgradeOperationId,
+            downloadAttemptId,
+            submissionLeaseId: null,
+            submissionLeaseDuration: null,
+            startedAt,
+            queuedDisposition,
+            cancellationToken);
+        return result.IsSuccess;
     }
 
-    public async Task<bool> TryStartDownloadAsync(
+    private readonly record struct DownloadStartResult(
+        bool IsSuccess,
+        DateTimeOffset? SubmissionLeaseUntil);
+
+    private async Task<DownloadStartResult> TryStartDownloadCoreAsync(
         Guid id,
+        Guid? releaseUpgradeOperationId,
         Guid downloadAttemptId,
+        Guid? submissionLeaseId,
+        TimeSpan? submissionLeaseDuration,
         DateTimeOffset startedAt,
         SubscriptionAutomationDisposition? queuedDisposition,
         CancellationToken cancellationToken)
@@ -566,18 +972,56 @@ public async Task<bool> TryStartDownloadAsync(
             await using var writeContext = new Models.ApplicationContext(contextOptions);
             await using var transaction = await writeContext.Database
                 .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
             var entity = await MappingTransactionLock.LockAnimationInfoAsync(
                 writeContext,
                 id,
                 cancellationToken);
             if (entity is null)
-                return false;
+                return new DownloadStartResult(false, null);
+
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            var hasLiveSubmissionLease =
+                entity.DownloadSubmissionLeaseId is not null &&
+                (entity.DownloadSubmissionLeaseUntil is null ||
+                 entity.DownloadSubmissionLeaseUntil > databaseNow);
+            if (hasLiveSubmissionLease &&
+                (releaseUpgradeOperationId is not null ||
+                 entity.DownloadSubmissionLeaseId != submissionLeaseId))
+                return new DownloadStartResult(false, null);
+
+            // Once an upgrade has claimed the candidate, only its attempt may
+            // establish tracking. This makes every tracked attempt on an active
+            // operation recoverably owned by that operation.
+            if (releaseUpgradeOperationId is null &&
+                (entity.DownloadCancellationLeaseUntil > databaseNow ||
+                 await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                     operation => operation.CandidateReleaseId == id &&
+                                  (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                   operation.Status == ReleaseUpgradeStatus.Verifying ||
+                                   (operation.DownloadSubmissionLeaseId != null &&
+                                    (operation.DownloadSubmissionLeaseUntil == null ||
+                                     operation.DownloadSubmissionLeaseUntil > databaseNow))),
+                     cancellationToken)))
+                return new DownloadStartResult(false, null);
+            if (releaseUpgradeOperationId is { } operationId &&
+                !await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation => operation.Id == operationId &&
+                                 operation.CandidateReleaseId == id &&
+                                 operation.Status == ReleaseUpgradeStatus.Downloading,
+                    cancellationToken))
+                return new DownloadStartResult(false, null);
             if (entity.IsDownloadTracked)
             {
                 // A transaction whose commit acknowledgement was lost can be
                 // retried safely with the caller-owned attempt identifier.
-                if (entity.DownloadAttemptId != downloadAttemptId)
-                    return false;
+                // Once cancellation intent is durable, however, the submitter
+                // must not resume that attempt while remote cleanup is in flight.
+                if (entity.DownloadAttemptId != downloadAttemptId ||
+                    entity.DownloadCancellationId is not null)
+                    return new DownloadStartResult(false, null);
             }
             else
             {
@@ -600,57 +1044,324 @@ await ResetTodoStateForTransitionAsync(
                 entity.IsDownloadTracked = true;
                 entity.IsDownloadFinished = false;
                 entity.DownloadAttemptId = downloadAttemptId;
+                entity.DownloadSubmissionLeaseId = null;
+                entity.DownloadSubmissionLeaseUntil = null;
                 entity.DownloadCancellationId = null;
+                entity.DownloadCancellationLeaseId = null;
+                entity.DownloadCancellationLeaseUntil = null;
+                entity.DownloadCancellationRemoveFile = false;
                 entity.DownloadStartTime = startedAt;
                 entity.FileStore = null;
                 entity.StorePath = null;
                 entity.AutomationDisposition = nextDisposition;
                 entity.StateVersion = checked(entity.StateVersion + 1);
-                await writeContext.SaveChangesAsync(cancellationToken);
             }
 
+            DateTimeOffset? submissionLeaseUntil = null;
+            if (submissionLeaseId is { } ordinaryLeaseId &&
+                submissionLeaseDuration is { } ordinaryLeaseDuration)
+            {
+                submissionLeaseUntil = databaseNow.Add(ordinaryLeaseDuration);
+                entity.DownloadSubmissionLeaseId = ordinaryLeaseId;
+                entity.DownloadSubmissionLeaseUntil = submissionLeaseUntil;
+            }
+
+            await writeContext.SaveChangesAsync(cancellationToken);
             await transaction.CommitAsync(cancellationToken);
-            return true;
+            return new DownloadStartResult(true, submissionLeaseUntil);
         });
     }
 
-    public async Task<bool> TryBeginCancelDownloadAsync(
+    public Task<DownloadCancellationLease?> TryBeginCancelDownloadAsync(
+        Guid id,
+        Guid? downloadAttemptId,
+        Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        TimeSpan cancellationLeaseDuration,
+        bool removeFile,
+        bool requireUnfinished,
+        SubscriptionAutomationDisposition? terminalDisposition,
+        CancellationToken cancellationToken) =>
+        TryBeginCancelDownloadCoreAsync(
+            id,
+            downloadAttemptId,
+            cancellationAttemptId,
+            cancellationLeaseId,
+            cancellationLeaseDuration,
+            removeFile,
+            requireUnfinished,
+            expectedExpiredSubmissionLeaseId: null,
+            terminalDisposition,
+            cancellationToken);
+
+    public Task<DownloadCancellationLease?> TryBeginExpiredDownloadSubmissionRecoveryAsync(
+        Guid id,
+        Guid downloadAttemptId,
+        Guid observedSubmissionLeaseId,
+        Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        TimeSpan cancellationLeaseDuration,
+        SubscriptionAutomationDisposition? terminalDisposition,
+        CancellationToken cancellationToken) =>
+        TryBeginCancelDownloadCoreAsync(
+            id,
+            downloadAttemptId,
+            cancellationAttemptId,
+            cancellationLeaseId,
+            cancellationLeaseDuration,
+            removeFile: false,
+            requireUnfinished: true,
+            expectedExpiredSubmissionLeaseId: observedSubmissionLeaseId,
+            terminalDisposition,
+            cancellationToken);
+
+    private async Task<DownloadCancellationLease?> TryBeginCancelDownloadCoreAsync(
         Guid id,
         Guid? downloadAttemptId,
         Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        TimeSpan cancellationLeaseDuration,
+        bool removeFile,
+        bool requireUnfinished,
+        Guid? expectedExpiredSubmissionLeaseId,
+        SubscriptionAutomationDisposition? terminalDisposition,
         CancellationToken cancellationToken)
     {
+        if (cancellationLeaseDuration <= TimeSpan.Zero ||
+            cancellationLeaseDuration > TimeSpan.FromMinutes(30))
+            throw new ArgumentOutOfRangeException(nameof(cancellationLeaseDuration));
+
         var strategy = context.Database.CreateExecutionStrategy();
         return await strategy.ExecuteAsync(async () =>
         {
             await using var writeContext = new Models.ApplicationContext(contextOptions);
             await using var transaction = await writeContext.Database
                 .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
             var entity = await MappingTransactionLock.LockAnimationInfoAsync(
                 writeContext,
                 id,
                 cancellationToken);
-            if (entity is null
-                || !entity.IsDownloadTracked
-                || entity.DownloadAttemptId != downloadAttemptId)
-                return false;
+            if (entity is null)
+                return null;
+
+            if (requireUnfinished && entity.IsDownloadFinished)
+                return null;
+
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+
+            if (expectedExpiredSubmissionLeaseId is { } expectedLeaseId &&
+                (entity.DownloadSubmissionLeaseId != expectedLeaseId ||
+                 entity.DownloadSubmissionLeaseUntil > databaseNow))
+                return null;
+
+            // A current release must not be deleted remotely while an upgrade
+            // candidate has only a durable local start and has not yet been
+            // confirmed remotely. Recovery owns that gap until SubmittedAt is
+            // persisted.
+            if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation =>
+                        operation.CurrentReleaseId == entity.Id &&
+                        (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                         operation.Status == ReleaseUpgradeStatus.Verifying) &&
+                        operation.DownloadSubmittedAt == null &&
+                        operation.CandidateRelease.IsDownloadTracked &&
+                        !operation.CandidateRelease.IsDownloadFinished,
+                    cancellationToken))
+                return null;
 
-            if (entity.DownloadCancellationId == cancellationAttemptId)
+            if (entity.DownloadCancellationLeaseUntil > databaseNow &&
+                entity.DownloadCancellationLeaseId != cancellationLeaseId)
+                return null;
+
+            var hasLiveOrdinarySubmissionLease =
+                entity.DownloadSubmissionLeaseId is not null &&
+                (entity.DownloadSubmissionLeaseUntil is null ||
+                 entity.DownloadSubmissionLeaseUntil > databaseNow);
+            if (hasLiveOrdinarySubmissionLease &&
+                entity.DownloadSubmissionLeaseId != cancellationLeaseId)
+                return null;
+
+            if (!entity.IsDownloadTracked)
             {
-                await transaction.CommitAsync(cancellationToken);
-                return true;
+                // A remote submission can complete after cancellation was
+                // finalized. Re-establish the same durable cancellation fence
+                // before deleting that late remote task, so a newer Start wins
+                // atomically and can never be deleted by the stale attempt.
+                if (entity.IsDownloadFinished ||
+                    entity.DownloadAttemptId is not null ||
+                    entity.DownloadCancellationId != cancellationAttemptId)
+                    return null;
+                entity.IsDownloadTracked = true;
+                entity.DownloadAttemptId = downloadAttemptId;
+                entity.StateVersion = checked(entity.StateVersion + 1);
+            }
+            else if (entity.DownloadAttemptId != downloadAttemptId)
+            {
+                return null;
             }
-            if (entity.DownloadCancellationId is not null)
-                return false;
 
-            entity.DownloadCancellationId = cancellationAttemptId;
-            entity.StateVersion = checked(entity.StateVersion + 1);
+            if (entity.DownloadCancellationId is not null &&
+                entity.DownloadCancellationId != cancellationAttemptId)
+                return null;
+
+            // If activation acquired the shared mapping lock first, this is a
+            // stale cancellation request for a release that is now live. Do
+            // not let the caller delete its remote files after activation.
+            if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation => operation.CandidateReleaseId == entity.Id &&
+                                 operation.Status == ReleaseUpgradeStatus.Applied,
+                    cancellationToken))
+                return null;
+
+            var isNewCancellation = entity.DownloadCancellationId is null;
+            if (isNewCancellation)
+            {
+                entity.DownloadCancellationId = cancellationAttemptId;
+                if (terminalDisposition is { } disposition &&
+                    entity.AutomationDisposition != disposition)
+                {
+                    await ResetTodoStateForTransitionAsync(
+                        writeContext,
+                        entity,
+                        entity.MetadataStatus,
+                        disposition,
+                        cancellationToken);
+                    entity.AutomationDisposition = disposition;
+                }
+                entity.StateVersion = checked(entity.StateVersion + 1);
+            }
+
+            var effectiveRemoveFile = entity.DownloadCancellationRemoveFile || removeFile;
+            entity.DownloadCancellationRemoveFile = effectiveRemoveFile;
+
+            // Persist the cancellation intent and terminate the pending
+            // upgrade atomically. Activation uses the same global lock, so it
+            // can no longer commit between remote deletion and local finalize.
+            var outgoingOperations = await writeContext.ReleaseUpgradeOperations
+                .Where(operation => operation.CurrentReleaseId == entity.Id &&
+                                    (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                     operation.Status == ReleaseUpgradeStatus.Verifying))
+                .ToListAsync(cancellationToken);
+            foreach (var operation in outgoingOperations)
+            {
+                operation.Status = ReleaseUpgradeStatus.Failed;
+                operation.FailureSummary =
+                    "Current release cancellation superseded the pending upgrade.";
+                operation.CompletedAt = databaseNow;
+            }
+
+            var pendingOperations = await writeContext.ReleaseUpgradeOperations
+                .Where(operation => operation.CandidateReleaseId == entity.Id &&
+                                    (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                     operation.Status == ReleaseUpgradeStatus.Verifying))
+                .OrderByDescending(operation => operation.CreatedAt)
+                .ToListAsync(cancellationToken);
+            foreach (var operation in pendingOperations)
+            {
+                operation.Status = ReleaseUpgradeStatus.Failed;
+                operation.FailureSummary =
+                    "Candidate download cancellation was requested before upgrade activation.";
+                operation.CompletedAt = databaseNow;
+            }
+
+            var terminalOperations = await writeContext.ReleaseUpgradeOperations
+                .Where(operation =>
+                    operation.CandidateReleaseId == entity.Id &&
+                    (operation.Status == ReleaseUpgradeStatus.Failed ||
+                     operation.Status == ReleaseUpgradeStatus.RolledBack ||
+                     operation.Status == ReleaseUpgradeStatus.Completed))
+                .OrderByDescending(operation => operation.CreatedAt)
+                .ToListAsync(cancellationToken);
+            terminalOperations.InsertRange(0, pendingOperations);
+            foreach (var operation in terminalOperations)
+                operation.DownloadCancellationRemoveFile = effectiveRemoveFile;
+
+            var activeSubmissionOperations = terminalOperations
+                .Where(operation =>
+                    operation.DownloadSubmissionLeaseId != null &&
+                    operation.DownloadSubmissionLeaseId != cancellationLeaseId &&
+                    operation.DownloadSubmissionLeaseUntil > databaseNow)
+                .ToList();
+            var cancellationLeaseUntil = databaseNow.Add(cancellationLeaseDuration);
+            if (hasLiveOrdinarySubmissionLease &&
+                entity.DownloadSubmissionLeaseUntil > cancellationLeaseUntil)
+                cancellationLeaseUntil = entity.DownloadSubmissionLeaseUntil.Value;
+            if (activeSubmissionOperations.Count > 0)
+            {
+                var latestSubmissionLeaseUntil = activeSubmissionOperations
+                    .Max(operation => operation.DownloadSubmissionLeaseUntil);
+                if (latestSubmissionLeaseUntil > cancellationLeaseUntil)
+                    cancellationLeaseUntil = latestSubmissionLeaseUntil.Value;
+            }
+
+            entity.DownloadCancellationLeaseId = cancellationLeaseId;
+            entity.DownloadCancellationLeaseUntil = cancellationLeaseUntil;
+
+            if (activeSubmissionOperations.Count == 0)
+            {
+                var recoveryOperation = terminalOperations.FirstOrDefault();
+                foreach (var operation in terminalOperations)
+                {
+                    operation.DownloadSubmissionLeaseId = null;
+                    operation.DownloadSubmissionLeaseUntil = null;
+                }
+                if (recoveryOperation is not null)
+                {
+                    recoveryOperation.DownloadSubmissionLeaseId = cancellationLeaseId;
+                    recoveryOperation.DownloadSubmissionLeaseUntil = cancellationLeaseUntil;
+                }
+            }
+            else
+            {
+                // Preserve every still-live submission fence. A cancellation
+                // may delete now, but it cannot finalize until any potentially
+                // late submission has expired and been deleted again.
+                foreach (var operation in terminalOperations.Except(activeSubmissionOperations))
+                {
+                    operation.DownloadSubmissionLeaseId = null;
+                    operation.DownloadSubmissionLeaseUntil = null;
+                }
+            }
             await writeContext.SaveChangesAsync(cancellationToken);
             await transaction.CommitAsync(cancellationToken);
-            return true;
+            return new DownloadCancellationLease(
+                cancellationLeaseId,
+                cancellationLeaseUntil,
+                effectiveRemoveFile);
         });
     }
 
+    public async Task<IReadOnlyList<PendingDownloadCancellation>>
+        GetPendingDownloadCancellationsAsync(
+            int take,
+            CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200)
+            throw new ArgumentOutOfRangeException(nameof(take));
+
+        var databaseNow = await context.Database
+            .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+            .SingleAsync(cancellationToken);
+        return await context.AnimationInfo
+            .AsNoTracking()
+            .Where(info =>
+                info.IsDownloadTracked &&
+                info.DownloadCancellationId != null &&
+                (info.DownloadCancellationLeaseUntil == null ||
+                 info.DownloadCancellationLeaseUntil <= databaseNow))
+            .OrderBy(info => info.DownloadCancellationLeaseUntil)
+            .ThenBy(info => info.DownloadStartTime)
+            .ThenBy(info => info.Id)
+            .Select(info => new PendingDownloadCancellation(
+                info.Id,
+                info.DownloadCancellationRemoveFile))
+            .Take(take)
+            .ToListAsync(cancellationToken);
+    }
+
     public async Task<AnimationInfo?> TryCompleteDownloadAsync(
         Guid id,
         Guid? downloadAttemptId,
@@ -695,6 +1406,14 @@ public async Task<bool> TryBeginCancelDownloadAsync(
                 return null;
             }
 
+            if (entity.DownloadSubmissionLeaseId is not null ||
+                entity.DownloadSubmissionLeaseUntil is not null)
+            {
+                entity.DownloadSubmissionLeaseId = null;
+                entity.DownloadSubmissionLeaseUntil = null;
+                changed = true;
+            }
+
             if (entity.AutomationDisposition is
                 SubscriptionAutomationDisposition.AutoDownloadQueued or
                 SubscriptionAutomationDisposition.ManualDownloadQueued)
@@ -738,6 +1457,7 @@ await writeContext.Entry(entity)
             await using var writeContext = new Models.ApplicationContext(contextOptions);
             await using var transaction = await writeContext.Database
                 .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
             var entity = await MappingTransactionLock.LockAnimationInfoAsync(
                 writeContext,
                 id,
@@ -745,6 +1465,24 @@ await writeContext.Entry(entity)
             if (entity is null)
                 return null;
 
+            if (entity.IsDownloadTracked)
+            {
+                var databaseNow = await writeContext.Database
+                    .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                    .SingleAsync(cancellationToken);
+                if ((entity.DownloadSubmissionLeaseId is not null &&
+                     (entity.DownloadSubmissionLeaseUntil is null ||
+                      entity.DownloadSubmissionLeaseUntil > databaseNow)) ||
+                    entity.DownloadCancellationLeaseUntil > databaseNow ||
+                    await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                        operation => operation.CandidateReleaseId == entity.Id &&
+                                     operation.DownloadSubmissionLeaseId != null &&
+                                     (operation.DownloadSubmissionLeaseUntil == null ||
+                                      operation.DownloadSubmissionLeaseUntil > databaseNow),
+                        cancellationToken))
+                    return null;
+            }
+
             if (entity.IsDownloadTracked)
             {
                 if (entity.DownloadAttemptId != downloadAttemptId
@@ -754,7 +1492,12 @@ await writeContext.Entry(entity)
                 entity.IsDownloadTracked = false;
                 entity.IsDownloadFinished = false;
                 entity.DownloadAttemptId = null;
+                entity.DownloadSubmissionLeaseId = null;
+                entity.DownloadSubmissionLeaseUntil = null;
                 entity.DownloadCancellationId = null;
+                entity.DownloadCancellationLeaseId = null;
+                entity.DownloadCancellationLeaseUntil = null;
+                entity.DownloadCancellationRemoveFile = false;
                 var nextDisposition = terminalDisposition
                     ?? (entity.AutomationDisposition is
                         SubscriptionAutomationDisposition.AutoDownloadQueued or
@@ -770,6 +1513,19 @@ await ResetTodoStateForTransitionAsync(
                     cancellationToken);
                 entity.AutomationDisposition = nextDisposition;
                 entity.StateVersion = checked(entity.StateVersion + 1);
+                var cancelledAt = DateTimeOffset.UtcNow;
+                await writeContext.ReleaseUpgradeOperations
+                    .Where(operation => operation.CandidateReleaseId == entity.Id &&
+                                        (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                         operation.Status == ReleaseUpgradeStatus.Verifying))
+                    .ExecuteUpdateAsync(
+                        setters => setters
+                            .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Failed)
+                            .SetProperty(
+                                operation => operation.FailureSummary,
+                                "Candidate download was cancelled before upgrade activation.")
+                            .SetProperty(operation => operation.CompletedAt, cancelledAt),
+                        cancellationToken);
                 await writeContext.SaveChangesAsync(cancellationToken);
             }
             else if (entity.DownloadAttemptId is not null
@@ -794,41 +1550,606 @@ public async Task<bool> TryUpdateAsync(
         long expectedStateVersion,
         CancellationToken cancellationToken)
     {
-        var entity = await context.AnimationInfo
-            .FirstOrDefaultAsync(candidate => candidate.Id == info.Id, cancellationToken);
-        if (entity is null || entity.StateVersion != expectedStateVersion)
-            return false;
-
-        await ResetTodoStateForTransitionAsync(
-            context,
-            entity,
-            info.MetadataStatus,
-            info.AutomationDisposition,
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database
+                .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var entity = await MappingTransactionLock.LockAnimationInfoAsync(
+                writeContext,
+                info.Id,
+                cancellationToken);
+            if (entity is null || entity.StateVersion != expectedStateVersion)
+                return false;
+            var previousEpisodeIdentity = GetEpisodeIdentity(writeContext, entity);
+            var wasActiveRelease = entity.IsActiveRelease;
+            var previousMappings = await writeContext.FileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == entity.Id)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
+            var previousMappingIdentities = await FileMappingSetReconciler.CaptureIdentitiesAsync(
+                writeContext,
+                previousMappings,
+                cancellationToken);
+
+            await ResetTodoStateForTransitionAsync(
+                writeContext,
+                entity,
+                info.MetadataStatus,
+                info.AutomationDisposition,
+                cancellationToken);
+            info.ApplyTo(entity);
+            entity.Animation = info.Animation is null
+                ? null
+                : await writeContext.Animations.FindAsync([info.Animation.Id], cancellationToken);
+            entity.Group = info.Group is null
+                ? null
+                : await writeContext.AnimationGroups.FindAsync([info.Group.Id], cancellationToken);
+            writeContext.Entry(entity).Property<Guid?>("AnimationId").CurrentValue = info.Animation?.Id;
+            writeContext.Entry(entity).Property<Guid?>("GroupId").CurrentValue = info.Group?.Id;
+            await SetEpisodeReleaseActivityAsync(
+                writeContext,
+                entity,
+                willHaveMappings: false,
+                cancellationToken);
+            await ReconcileMappingVisibilityAfterMetadataChangeAsync(
+                writeContext,
+                entity,
+                cancellationToken);
+            var currentEpisodeIdentity = entity.IsActiveRelease
+                ? GetEpisodeIdentity(writeContext, entity)
+                : null;
+            entity.StateVersion = checked(expectedStateVersion + 1);
+            writeContext.Entry(entity).Property(candidate => candidate.StateVersion).OriginalValue =
+                expectedStateVersion;
+
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await PromotePreviousEpisodeSuccessorAsync(
+                writeContext,
+                entity.Id,
+                wasActiveRelease,
+                previousEpisodeIdentity,
+                currentEpisodeIdentity,
+                previousMappings,
+                retainChangedReleaseMappings: true,
+                cancellationToken);
+            await previousMappingIdentities.RestoreEntryIdentitiesAsync(
+                writeContext,
+                cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return true;
+        });
+    }
+
+    internal static async Task SetEpisodeReleaseActivityAsync(
+        Models.ApplicationContext writeContext,
+        Models.AnimationInfo entity,
+        bool willHaveMappings,
+        CancellationToken cancellationToken)
+    {
+        var identity = GetEpisodeIdentity(writeContext, entity);
+        var hasMappings = willHaveMappings ||
+                          await writeContext.FileMappings.AsNoTracking()
+                              .AnyAsync(mapping => mapping.AnimationInfoId == entity.Id, cancellationToken) ||
+                          await writeContext.StagedFileMappings.AsNoTracking()
+                              .AnyAsync(mapping => mapping.AnimationInfoId == entity.Id, cancellationToken);
+        if (identity is null || entity.MediaLibraryMissingSince is not null ||
+            !entity.IsDownloadFinished || !hasMappings)
+        {
+            entity.IsActiveRelease = false;
+            return;
+        }
+
+        var value = identity.Value;
+        var activeOthers = writeContext.AnimationInfo
+            .Where(other => other.Id != entity.Id &&
+                            other.IsActiveRelease &&
+                            EF.Property<Guid?>(other, "AnimationId") == value.AnimationId &&
+                            other.Season == value.Season &&
+                            other.Episode == value.Episode);
+        if (await activeOthers.AsNoTracking().AnyAsync(other =>
+                other.MediaLibraryMissingSince == null &&
+                other.IsDownloadFinished &&
+                writeContext.FileMappings.Any(mapping => mapping.AnimationInfoId == other.Id),
+                cancellationToken))
+        {
+            entity.IsActiveRelease = false;
+            return;
+        }
+
+        await activeOthers.ExecuteUpdateAsync(
+            setters => setters
+                .SetProperty(other => other.IsActiveRelease, false)
+                .SetProperty(other => other.IsRetiredRelease, true)
+                .SetProperty(other => other.StateVersion, other => other.StateVersion + 1),
             cancellationToken);
-        info.ApplyTo(entity);
-        entity.Animation = info.Animation is null
-            ? null
-            : await context.Animations.FindAsync([info.Animation.Id], cancellationToken);
-        entity.Group = info.Group is null
-            ? null
-            : await context.AnimationGroups.FindAsync([info.Group.Id], cancellationToken);
-        entity.StateVersion = checked(expectedStateVersion + 1);
-        context.Entry(entity).Property(candidate => candidate.StateVersion).OriginalValue = expectedStateVersion;
+        entity.IsActiveRelease = true;
+        entity.IsRetiredRelease = false;
+    }
 
-        try
+    internal static EpisodeReleaseIdentity? GetEpisodeIdentity(
+        Models.ApplicationContext writeContext,
+        Models.AnimationInfo entity)
+    {
+        writeContext.ChangeTracker.DetectChanges();
+        var animationId = entity.Animation?.Id ?? writeContext.Entry(entity)
+            .Property<Guid?>("AnimationId")
+            .CurrentValue;
+        return animationId is { } id && entity.Season is { } season && entity.Episode is { } episode
+            ? new EpisodeReleaseIdentity(id, season, episode)
+            : null;
+    }
+
+    private static async Task ReconcileMappingVisibilityAfterMetadataChangeAsync(
+        Models.ApplicationContext writeContext,
+        Models.AnimationInfo entity,
+        CancellationToken cancellationToken)
+    {
+        var liveMappings = await writeContext.FileMappings
+            .Where(mapping => mapping.AnimationInfoId == entity.Id)
+            .ToListAsync(cancellationToken);
+        var stagedMappings = await writeContext.StagedFileMappings
+            .Where(mapping => mapping.AnimationInfoId == entity.Id)
+            .ToListAsync(cancellationToken);
+        var shouldStage = GetEpisodeIdentity(writeContext, entity) is not null &&
+                          !entity.IsActiveRelease;
+
+        if (shouldStage)
         {
-            await context.SaveChangesAsync(cancellationToken);
-            return true;
+            if (liveMappings.Count == 0) return;
+
+            writeContext.StagedFileMappings.RemoveRange(stagedMappings);
+            await writeContext.StagedFileMappings.AddRangeAsync(
+                liveMappings.Select(mapping => new Models.StagedFileMapping
+                {
+                    Id = mapping.Id,
+                    AnimationInfoId = mapping.AnimationInfoId,
+                    VirtualPath = mapping.VirtualPath,
+                    PhysicalPath = mapping.PhysicalPath,
+                    FileStore = mapping.FileStore
+                }),
+                cancellationToken);
+            writeContext.FileMappings.RemoveRange(liveMappings);
+            return;
+        }
+
+        if (liveMappings.Count > 0)
+        {
+            writeContext.StagedFileMappings.RemoveRange(stagedMappings);
+            return;
+        }
+
+        if (stagedMappings.Count == 0) return;
+        var conflicts = await VirtualPathNamespaceGuard.FindConflictsAsync(
+            writeContext,
+            entity.Id,
+            stagedMappings.Select(mapping => mapping.VirtualPath).ToArray(),
+            cancellationToken);
+        if (conflicts.Count > 0)
+            throw new InvalidOperationException(
+                $"Cannot publish the remapped release because '{conflicts[0].OccupiedPath}' is occupied.");
+
+        await writeContext.FileMappings.AddRangeAsync(
+            stagedMappings.Select(mapping => new Models.FileMapping
+            {
+                Id = mapping.Id,
+                AnimationInfoId = mapping.AnimationInfoId,
+                VirtualPath = mapping.VirtualPath,
+                PhysicalPath = mapping.PhysicalPath,
+                FileStore = mapping.FileStore
+            }),
+            cancellationToken);
+        writeContext.StagedFileMappings.RemoveRange(stagedMappings);
+    }
+
+    internal static async Task PromotePreviousEpisodeSuccessorAsync(
+        Models.ApplicationContext writeContext,
+        Guid changedReleaseId,
+        bool wasActiveRelease,
+        EpisodeReleaseIdentity? previousIdentity,
+        EpisodeReleaseIdentity? currentIdentity,
+        IReadOnlyList<Models.FileMapping> previousMappings,
+        bool retainChangedReleaseMappings,
+        CancellationToken cancellationToken)
+    {
+        if (!wasActiveRelease || previousIdentity is not { } previous || previous == currentIdentity)
+            return;
+        if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                operation =>
+                    operation.CurrentReleaseId == changedReleaseId &&
+                    (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                     operation.Status == ReleaseUpgradeStatus.Verifying) &&
+                    operation.DownloadSubmittedAt == null &&
+                    operation.CandidateRelease.IsDownloadTracked &&
+                    !operation.CandidateRelease.IsDownloadFinished,
+                cancellationToken))
+            throw new InvalidOperationException(
+                "The release cannot leave its episode while an upgrade submission is awaiting remote confirmation.");
+        var supersededAt = DateTimeOffset.UtcNow;
+        await writeContext.ReleaseUpgradeOperations
+            .Where(operation =>
+                (operation.CurrentReleaseId == changedReleaseId ||
+                 operation.CandidateReleaseId == changedReleaseId) &&
+                (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                 operation.Status == ReleaseUpgradeStatus.Verifying))
+            .ExecuteUpdateAsync(
+                setters => setters
+                    .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Failed)
+                    .SetProperty(
+                        operation => operation.FailureSummary,
+                        "Upgrade was superseded because a referenced release left the episode before activation.")
+                    .SetProperty(operation => operation.CompletedAt, supersededAt),
+                cancellationToken);
+        await writeContext.ReleaseUpgradeOperations
+            .Where(operation => operation.CandidateReleaseId == changedReleaseId &&
+                                operation.Status == ReleaseUpgradeStatus.Applied)
+            .ExecuteUpdateAsync(
+                setters => setters
+                    .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Completed)
+                    .SetProperty(operation => operation.CompletedAt, supersededAt),
+                cancellationToken);
+        if (previousMappings.Count == 0)
+            return;
+        if (await writeContext.AnimationInfo.AsNoTracking().AnyAsync(
+                info => info.Id != changedReleaseId &&
+                        info.IsActiveRelease &&
+                        EF.Property<Guid?>(info, "AnimationId") == previous.AnimationId &&
+                        info.Season == previous.Season &&
+                        info.Episode == previous.Episode,
+                cancellationToken))
+            return;
+
+        var ancestorLineages = await GetAncestorLineagesAsync(
+            writeContext,
+            changedReleaseId,
+            cancellationToken);
+        var ancestorIds = ancestorLineages.Keys.ToArray();
+        var successorId = await writeContext.AnimationInfo
+            .AsNoTracking()
+            .Where(info => info.Id != changedReleaseId &&
+                           !info.IsActiveRelease &&
+                           info.MediaLibraryMissingSince == null &&
+                           info.IsDownloadFinished &&
+                           info.DownloadCancellationId == null &&
+                           (writeContext.FileMappings.Any(mapping => mapping.AnimationInfoId == info.Id) ||
+                            writeContext.StagedFileMappings.Any(mapping => mapping.AnimationInfoId == info.Id) ||
+                            ancestorIds.Contains(info.Id)) &&
+                           EF.Property<Guid?>(info, "AnimationId") == previous.AnimationId &&
+                           info.Season == previous.Season &&
+                           info.Episode == previous.Episode)
+            .OrderByDescending(info => info.ReleaseScore)
+            .ThenByDescending(info => info.PublishTime)
+            .ThenBy(info => info.Id)
+            .Select(info => (Guid?)info.Id)
+            .FirstOrDefaultAsync(cancellationToken);
+        if (!successorId.HasValue) return;
+
+        var successor = await MappingTransactionLock.LockAnimationInfoAsync(
+            writeContext,
+            successorId.Value,
+            cancellationToken);
+        if (successor is null ||
+            successor.IsActiveRelease ||
+            successor.MediaLibraryMissingSince is not null ||
+            !successor.IsDownloadFinished ||
+            successor.DownloadCancellationId is not null ||
+            GetEpisodeIdentity(writeContext, successor) != previous)
+            return;
+
+        var successorLiveMappings = await writeContext.FileMappings
+            .AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == successor.Id)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .ToListAsync(cancellationToken);
+        var successorStagedMappings = await writeContext.StagedFileMappings
+            .Where(mapping => mapping.AnimationInfoId == successor.Id)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .ToListAsync(cancellationToken);
+        if (successorLiveMappings.Count > 0 && successorStagedMappings.Count > 0)
+            return;
+
+        AncestorLineage? ancestorLineage = null;
+        List<Models.FileMapping> candidateMappings;
+        if (successorLiveMappings.Count > 0)
+        {
+            candidateMappings = successorLiveMappings;
+        }
+        else if (successorStagedMappings.Count > 0)
+        {
+            candidateMappings = successorStagedMappings
+                .Select(mapping => new Models.FileMapping
+                {
+                    Id = mapping.Id,
+                    AnimationInfoId = mapping.AnimationInfoId,
+                    VirtualPath = mapping.VirtualPath,
+                    PhysicalPath = mapping.PhysicalPath,
+                    FileStore = mapping.FileStore
+                })
+                .ToList();
+        }
+        else
+        {
+            ancestorLineages.TryGetValue(successor.Id, out ancestorLineage);
+            candidateMappings = ancestorLineage?.PreviousMappings ?? [];
         }
-        catch (DbUpdateConcurrencyException)
+        if (candidateMappings.Count == 0) return;
+
+        var replacement = ReleaseUpgradeRepository.BuildCandidateReplacement(
+            previousMappings,
+            candidateMappings,
+            successor.Id);
+        var retainedMappings = retainChangedReleaseMappings
+            ? await writeContext.FileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == changedReleaseId)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken)
+            : [];
+        var retainedStagedMappings = retainChangedReleaseMappings
+            ? await writeContext.StagedFileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == changedReleaseId)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .Select(mapping => new Models.FileMapping
+                {
+                    Id = mapping.Id,
+                    AnimationInfoId = mapping.AnimationInfoId,
+                    VirtualPath = mapping.VirtualPath,
+                    PhysicalPath = mapping.PhysicalPath,
+                    FileStore = mapping.FileStore
+                })
+                .ToListAsync(cancellationToken)
+            : [];
+        var successorPaths = replacement.Mappings
+            .Select(mapping => mapping.VirtualPath)
+            .ToHashSet(StringComparer.Ordinal);
+        var vacatedCandidatePaths = replacement.CandidatePathReplacements
+            .Where(pair => !string.Equals(pair.Key, pair.Value, StringComparison.Ordinal))
+            .ToDictionary(pair => pair.Value, pair => pair.Key, StringComparer.Ordinal);
+        var retainedSnapshotPaths = ancestorLineage?.ChangedCandidateMappings
+            .GroupBy(mapping => (mapping.PhysicalPath, mapping.FileStore))
+            .ToDictionary(group => group.Key, group => group.First().VirtualPath)
+            ?? [];
+        var retainedPlaybackRelocations = new Dictionary<
+            ReleaseUpgradeRepository.PlaybackLocation,
+            ReleaseUpgradeRepository.PlaybackLocation>();
+        var retainedPhysicalMappings = retainedMappings.Count > 0
+            ? retainedMappings
+            : retainedStagedMappings;
+        foreach (var pathTarget in PlaybackProgressMappingMigrator.BuildPathTargets(
+                     previousMappings,
+                     retainedPhysicalMappings))
+        {
+            if (pathTarget.Value is not { } targetPath) continue;
+            retainedPlaybackRelocations[
+                new ReleaseUpgradeRepository.PlaybackLocation(
+                    changedReleaseId,
+                    pathTarget.Key)] =
+                new ReleaseUpgradeRepository.PlaybackLocation(
+                    changedReleaseId,
+                    targetPath);
+        }
+
+        var retainedDesiredMappings = new List<Models.FileMapping>(retainedMappings.Count);
+        var reservedPaths = successorPaths.ToHashSet(StringComparer.Ordinal);
+        foreach (var mapping in retainedMappings)
+        {
+            if (successorPaths.Contains(mapping.VirtualPath))
+            {
+                var preferredPath = vacatedCandidatePaths.GetValueOrDefault(mapping.VirtualPath)
+                                    ?? retainedSnapshotPaths.GetValueOrDefault(
+                                        (mapping.PhysicalPath, mapping.FileStore))
+                                    ?? mapping.VirtualPath;
+                var relocatedPath = await FindAvailableRetainedPathAsync(
+                    writeContext,
+                    [changedReleaseId, successor.Id],
+                    preferredPath,
+                    mapping.VirtualPath,
+                    reservedPaths,
+                    cancellationToken);
+                if (relocatedPath is null)
+                    return;
+                retainedDesiredMappings.Add(new Models.FileMapping
+                {
+                    Id = Guid.NewGuid(),
+                    AnimationInfoId = mapping.AnimationInfoId,
+                    VirtualPath = relocatedPath,
+                    PhysicalPath = mapping.PhysicalPath,
+                    FileStore = mapping.FileStore
+                });
+                retainedPlaybackRelocations[
+                    new ReleaseUpgradeRepository.PlaybackLocation(
+                        mapping.AnimationInfoId,
+                        mapping.VirtualPath)] =
+                    new ReleaseUpgradeRepository.PlaybackLocation(
+                        mapping.AnimationInfoId,
+                        relocatedPath);
+                reservedPaths.Add(relocatedPath);
+            }
+            else
+            {
+                retainedDesiredMappings.Add(mapping);
+                reservedPaths.Add(mapping.VirtualPath);
+            }
+        }
+
+        var desiredMappings = retainedDesiredMappings
+            .Concat(replacement.Mappings)
+            .ToList();
+        var conflicts = await VirtualPathNamespaceGuard.FindConflictsAsync(
+            writeContext,
+            [changedReleaseId, successor.Id],
+            desiredMappings.Select(mapping => mapping.VirtualPath).ToArray(),
+            cancellationToken);
+        if (conflicts.Count > 0) return;
+
+        var reconciliation = await FileMappingSetReconciler.ReconcileAcrossOwnersAsync(
+            writeContext,
+            [changedReleaseId, successor.Id],
+            desiredMappings,
+            cancellationToken);
+        if (successorStagedMappings.Count > 0)
+            writeContext.StagedFileMappings.RemoveRange(successorStagedMappings);
+
+        var playbackTransfers = ReleaseUpgradeRepository.BuildActivationPlaybackTransfers(
+                changedReleaseId,
+                successor.Id,
+                replacement)
+            .ToDictionary();
+        foreach (var relocation in retainedPlaybackRelocations)
+            playbackTransfers[relocation.Key] = relocation.Value;
+        await ReleaseUpgradeRepository.TransferPlaybackProgressAsync(
+            writeContext,
+            playbackTransfers,
+            cancellationToken);
+
+        if (!retainChangedReleaseMappings)
+            await writeContext.AnimationInfo
+                .Where(info => info.Id == changedReleaseId)
+                .ExecuteUpdateAsync(
+                    setters => setters.SetProperty(info => info.IsRetiredRelease, true),
+                    cancellationToken);
+        successor.IsActiveRelease = true;
+        successor.IsRetiredRelease = false;
+        successor.StateVersion = checked(successor.StateVersion + 1);
+        await writeContext.SaveChangesAsync(cancellationToken);
+        await reconciliation.RestoreEntryIdentitiesAsync(writeContext, cancellationToken);
+    }
+
+    private static async Task<Dictionary<Guid, AncestorLineage>> GetAncestorLineagesAsync(
+        Models.ApplicationContext writeContext,
+        Guid changedReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var result = new Dictionary<Guid, AncestorLineage>();
+        var visited = new HashSet<Guid> { changedReleaseId };
+        var descendantReleaseId = changedReleaseId;
+        var depth = 0;
+        List<Models.FileMapping>? changedCandidateMappings = null;
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .AsNoTracking()
+                .Include(item => item.MappingSnapshots)
+                .Where(item =>
+                    item.CandidateReleaseId == descendantReleaseId &&
+                    (item.Status == ReleaseUpgradeStatus.Applied ||
+                     item.Status == ReleaseUpgradeStatus.Completed))
+                .OrderByDescending(item => item.AppliedAt)
+                .ThenByDescending(item => item.CreatedAt)
+                .FirstOrDefaultAsync(cancellationToken);
+            if (operation is null || !visited.Add(operation.CurrentReleaseId))
+                break;
+            depth++;
+
+            changedCandidateMappings ??= operation.MappingSnapshots
+                .Where(snapshot =>
+                    snapshot.Kind == ReleaseUpgradeMappingKind.Candidate &&
+                    snapshot.AnimationInfoId == changedReleaseId)
+                .OrderBy(snapshot => snapshot.VirtualPath, StringComparer.Ordinal)
+                .Select(FromUpgradeSnapshot)
+                .ToList();
+            var previousMappings = operation.MappingSnapshots
+                .Where(snapshot =>
+                    snapshot.Kind == ReleaseUpgradeMappingKind.Previous &&
+                    snapshot.AnimationInfoId == operation.CurrentReleaseId)
+                .OrderBy(snapshot => snapshot.VirtualPath, StringComparer.Ordinal)
+                .Select(FromUpgradeSnapshot)
+                .ToList();
+            if (previousMappings.Count > 0)
+            {
+                result[operation.CurrentReleaseId] = new AncestorLineage(
+                    previousMappings,
+                    changedCandidateMappings,
+                    operation.Id,
+                    operation.CurrentScore,
+                    depth);
+            }
+
+            descendantReleaseId = operation.CurrentReleaseId;
+        }
+
+        return result;
+    }
+
+    private static Models.FileMapping FromUpgradeSnapshot(
+        Models.ReleaseUpgradeMappingSnapshot snapshot) => new()
+        {
+            Id = snapshot.OriginalMappingId,
+            AnimationInfoId = snapshot.AnimationInfoId,
+            VirtualPath = snapshot.VirtualPath,
+            PhysicalPath = snapshot.PhysicalPath,
+            FileStore = snapshot.FileStore
+        };
+
+    private static async Task<string?> FindAvailableRetainedPathAsync(
+        Models.ApplicationContext writeContext,
+        IReadOnlyCollection<Guid> mappingOwners,
+        string preferredPath,
+        string fallbackPath,
+        IReadOnlyCollection<string> reservedPaths,
+        CancellationToken cancellationToken)
+    {
+        foreach (var basePath in new[] { preferredPath, fallbackPath }
+                     .Distinct(StringComparer.Ordinal))
         {
-            // The transition may also have staged a todo-state deletion. None
-            // of those tracked changes belong to the losing revision.
-            context.ChangeTracker.Clear();
-            return false;
+            var candidate = basePath;
+            for (var suffix = 2; suffix <= 65; suffix++)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                if (reservedPaths.Any(path =>
+                        VirtualPathNamespaceGuard.IsAncestor(path, candidate)))
+                    break;
+                var hasBatchConflict = reservedPaths.Any(path =>
+                    string.Equals(path, candidate, StringComparison.Ordinal) ||
+                    VirtualPathNamespaceGuard.IsAncestor(candidate, path));
+                if (!hasBatchConflict)
+                {
+                    var conflicts = await VirtualPathNamespaceGuard.FindConflictsAsync(
+                        writeContext,
+                        mappingOwners,
+                        [candidate],
+                        cancellationToken);
+                    if (conflicts.Count == 0)
+                        return candidate;
+                    if (conflicts.Any(conflict =>
+                            conflict.Kind == VirtualPathConflictKind.AncestorFile))
+                        break;
+                }
+
+                candidate = AddCollisionSuffix(basePath, suffix);
+            }
         }
+
+        return null;
     }
 
+    private static string AddCollisionSuffix(string virtualPath, int suffix)
+    {
+        var slash = virtualPath.LastIndexOf('/');
+        var directory = virtualPath[..(slash + 1)];
+        var fileName = virtualPath[(slash + 1)..];
+        var extension = Path.GetExtension(fileName);
+        var stem = extension.Length == 0 ? fileName : fileName[..^extension.Length];
+        return $"{directory}{stem} ({suffix}){extension}";
+    }
+
+    private sealed record AncestorLineage(
+        List<Models.FileMapping> PreviousMappings,
+        List<Models.FileMapping> ChangedCandidateMappings,
+        Guid SourceOperationId,
+        int HistoricalScore,
+        int Depth);
+
+    internal readonly record struct EpisodeReleaseIdentity(Guid AnimationId, int Season, int Episode);
+
+    private static string? NormalizeExternalReleaseId(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
     private static async Task ResetTodoStateForTransitionAsync(
         Models.ApplicationContext writeContext,
         Models.AnimationInfo current,
diff --git a/SecondDimensionWatcherReDive/Repositories/FileMappingRepository.cs b/SecondDimensionWatcherReDive/Repositories/FileMappingRepository.cs
index 5af44de..9169fff 100644
--- a/SecondDimensionWatcherReDive/Repositories/FileMappingRepository.cs
+++ b/SecondDimensionWatcherReDive/Repositories/FileMappingRepository.cs
@@ -128,22 +128,58 @@ public async Task<bool> ReplaceForAnimationInfoAsync(
                 .AsNoTracking()
                 .Where(mapping => mapping.AnimationInfoId == animationInfoId)
                 .ToListAsync(cancellationToken);
+            var existingStagedMappings = await replaceContext.StagedFileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+                .ToListAsync(cancellationToken);
             var desiredMappings = mappings
                 .Select(mapping => mapping.ToEntity())
                 .ToList();
+            var previousEpisodeIdentity = AnimationInfoRepository.GetEpisodeIdentity(
+                replaceContext,
+                current);
+            var wasActiveRelease = current.IsActiveRelease;
+            await AnimationInfoRepository.SetEpisodeReleaseActivityAsync(
+                replaceContext,
+                current,
+                willHaveMappings: desiredMappings.Count > 0,
+                cancellationToken);
+            var shouldStage = previousEpisodeIdentity is not null && !current.IsActiveRelease;
+            var previousMappings = existingMappings.Count > 0
+                ? existingMappings
+                : existingStagedMappings.Select(ToFileMapping).ToList();
             await PlaybackProgressMappingMigrator.MigrateAsync(
                 replaceContext,
                 animationInfoId,
-                existingMappings,
+                previousMappings,
                 desiredMappings,
                 cancellationToken);
             var reconciliation = await FileMappingSetReconciler.ReconcileAsync(
                 replaceContext,
                 animationInfoId,
-                desiredMappings,
+                shouldStage ? [] : desiredMappings,
                 cancellationToken);
+            replaceContext.StagedFileMappings.RemoveRange(existingStagedMappings);
+            if (shouldStage)
+            {
+                await replaceContext.StagedFileMappings.AddRangeAsync(
+                    desiredMappings.Select(ToStagedFileMapping),
+                    cancellationToken);
+            }
+            var currentEpisodeIdentity = current.IsActiveRelease
+                ? AnimationInfoRepository.GetEpisodeIdentity(replaceContext, current)
+                : null;
             current.StateVersion = checked(current.StateVersion + 1);
             await replaceContext.SaveChangesAsync(cancellationToken);
+            await AnimationInfoRepository.PromotePreviousEpisodeSuccessorAsync(
+                replaceContext,
+                current.Id,
+                wasActiveRelease,
+                previousEpisodeIdentity,
+                currentEpisodeIdentity,
+                previousMappings,
+                retainChangedReleaseMappings: true,
+                cancellationToken);
             await reconciliation.RestoreEntryIdentitiesAsync(
                 replaceContext,
                 cancellationToken);
@@ -377,15 +413,18 @@ private static IQueryable<FileSystemEntry> ProjectFileSystemEntries(
 
     public async Task<bool> ExistsForAnimationInfoAsync(Guid animationInfoId, CancellationToken cancellationToken)
     {
-        return await context.FileMappings
-            .AsNoTracking()
-            .AnyAsync(m => m.AnimationInfoId == animationInfoId, cancellationToken);
+        return await context.FileMappings.AsNoTracking()
+                   .AnyAsync(m => m.AnimationInfoId == animationInfoId, cancellationToken)
+               || await context.StagedFileMappings.AsNoTracking()
+                   .AnyAsync(m => m.AnimationInfoId == animationInfoId, cancellationToken);
     }
 
     public async Task<bool> TryFinalizeDownloadCancellationAsync(
         Guid animationInfoId,
         Guid? downloadAttemptId,
         Guid cancellationAttemptId,
+        Guid cancellationLeaseId,
+        SubscriptionAutomationDisposition? terminalDisposition,
         CancellationToken cancellationToken)
     {
         var strategy = context.Database.CreateExecutionStrategy();
@@ -415,26 +454,97 @@ public async Task<bool> TryFinalizeDownloadCancellationAsync(
                 || animationInfo.DownloadCancellationId != cancellationAttemptId)
                 return false;
 
-            await finalizeContext.PlaybackProgresses
-                .Where(progress => progress.AnimationInfoId == animationInfoId)
-                .ExecuteDeleteAsync(cancellationToken);
-            await finalizeContext.FileMappings
+            var databaseNow = await finalizeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            if (animationInfo.DownloadCancellationLeaseId != cancellationLeaseId ||
+                animationInfo.DownloadCancellationLeaseUntil <= databaseNow)
+                return false;
+            if (animationInfo.DownloadSubmissionLeaseId is not null &&
+                animationInfo.DownloadSubmissionLeaseId != cancellationLeaseId &&
+                (animationInfo.DownloadSubmissionLeaseUntil is null ||
+                 animationInfo.DownloadSubmissionLeaseUntil > databaseNow))
+                return false;
+            if (await finalizeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation => operation.CandidateReleaseId == animationInfoId &&
+                                 operation.DownloadSubmissionLeaseId != null &&
+                                 operation.DownloadSubmissionLeaseId != cancellationLeaseId &&
+                                 (operation.DownloadSubmissionLeaseUntil == null ||
+                                  operation.DownloadSubmissionLeaseUntil > databaseNow),
+                    cancellationToken))
+                return false;
+
+            var previousEpisodeIdentity = AnimationInfoRepository.GetEpisodeIdentity(
+                finalizeContext,
+                animationInfo);
+            var wasActiveRelease = animationInfo.IsActiveRelease;
+            var previousMappings = await finalizeContext.FileMappings
+                .AsNoTracking()
                 .Where(mapping => mapping.AnimationInfoId == animationInfoId)
-                .ExecuteDeleteAsync(cancellationToken);
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
             animationInfo.IsDownloadTracked = false;
             animationInfo.IsDownloadFinished = false;
+            animationInfo.IsActiveRelease = false;
             animationInfo.DownloadAttemptId = null;
+            animationInfo.DownloadSubmissionLeaseId = null;
+            animationInfo.DownloadSubmissionLeaseUntil = null;
             // Retain the completed cancellation id until the next Start so a
             // lost commit acknowledgement can be retried idempotently.
             animationInfo.DownloadCancellationId = cancellationAttemptId;
-            animationInfo.AutomationDisposition = animationInfo.AutomationDisposition is
-                SubscriptionAutomationDisposition.AutoDownloadQueued or
-                SubscriptionAutomationDisposition.ManualDownloadQueued or
-                SubscriptionAutomationDisposition.DownloadCompleted
-                    ? SubscriptionAutomationDisposition.DownloadCancelled
-                    : animationInfo.AutomationDisposition;
+            animationInfo.DownloadCancellationLeaseId = null;
+            animationInfo.DownloadCancellationLeaseUntil = null;
+            animationInfo.AutomationDisposition = terminalDisposition
+                ?? (animationInfo.AutomationDisposition is
+                    SubscriptionAutomationDisposition.AutoDownloadQueued or
+                    SubscriptionAutomationDisposition.ManualDownloadQueued or
+                    SubscriptionAutomationDisposition.DownloadCompleted
+                        ? SubscriptionAutomationDisposition.DownloadCancelled
+                        : animationInfo.AutomationDisposition);
             animationInfo.StateVersion = checked(animationInfo.StateVersion + 1);
+            await finalizeContext.ReleaseUpgradeOperations
+                .Where(operation => operation.CandidateReleaseId == animationInfoId &&
+                                    (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                     operation.Status == ReleaseUpgradeStatus.Verifying))
+                .ExecuteUpdateAsync(
+                    setters => setters
+                        .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Failed)
+                        .SetProperty(
+                            operation => operation.FailureSummary,
+                            "Candidate download was cancelled before upgrade activation.")
+                        .SetProperty(operation => operation.CompletedAt, databaseNow),
+                    cancellationToken);
+            await finalizeContext.ReleaseUpgradeOperations
+                .Where(operation =>
+                    operation.CandidateReleaseId == animationInfoId &&
+                    operation.DownloadSubmissionLeaseId != null &&
+                    (operation.Status == ReleaseUpgradeStatus.Failed ||
+                     operation.Status == ReleaseUpgradeStatus.RolledBack ||
+                     operation.Status == ReleaseUpgradeStatus.Completed))
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(operation => operation.DownloadSubmissionLeaseId, (Guid?)null)
+                        .SetProperty(operation => operation.DownloadSubmissionLeaseUntil,
+                            (DateTimeOffset?)null),
+                    cancellationToken);
             await finalizeContext.SaveChangesAsync(cancellationToken);
+            await AnimationInfoRepository.PromotePreviousEpisodeSuccessorAsync(
+                finalizeContext,
+                animationInfo.Id,
+                wasActiveRelease,
+                previousEpisodeIdentity,
+                currentIdentity: null,
+                previousMappings,
+                retainChangedReleaseMappings: false,
+                cancellationToken);
+            await finalizeContext.PlaybackProgresses
+                .Where(progress => progress.AnimationInfoId == animationInfoId)
+                .ExecuteDeleteAsync(cancellationToken);
+            await finalizeContext.FileMappings
+                .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+                .ExecuteDeleteAsync(cancellationToken);
+            await finalizeContext.StagedFileMappings
+                .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+                .ExecuteDeleteAsync(cancellationToken);
             await transaction.CommitAsync(cancellationToken);
             return true;
         });
@@ -454,16 +564,57 @@ await strategy.ExecuteAsync(async () =>
                 removeContext,
                 animationInfoId,
                 cancellationToken);
-            await removeContext.FileMappings
+            var previousEpisodeIdentity = animationInfo is null
+                ? null
+                : AnimationInfoRepository.GetEpisodeIdentity(removeContext, animationInfo);
+            var wasActiveRelease = animationInfo?.IsActiveRelease == true;
+            var previousMappings = await removeContext.FileMappings
+                .AsNoTracking()
                 .Where(mapping => mapping.AnimationInfoId == animationInfoId)
-                .ExecuteDeleteAsync(cancellationToken);
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
             if (animationInfo is not null)
             {
+                animationInfo.IsActiveRelease = false;
                 animationInfo.StateVersion = checked(animationInfo.StateVersion + 1);
                 await removeContext.SaveChangesAsync(cancellationToken);
+                await AnimationInfoRepository.PromotePreviousEpisodeSuccessorAsync(
+                    removeContext,
+                    animationInfo.Id,
+                    wasActiveRelease,
+                    previousEpisodeIdentity,
+                    currentIdentity: null,
+                    previousMappings,
+                    retainChangedReleaseMappings: false,
+                    cancellationToken);
             }
 
+            await removeContext.FileMappings
+                .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+                .ExecuteDeleteAsync(cancellationToken);
+            await removeContext.StagedFileMappings
+                .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+                .ExecuteDeleteAsync(cancellationToken);
+
             await transaction.CommitAsync(cancellationToken);
         });
     }
+
+    private static Models.FileMapping ToFileMapping(Models.StagedFileMapping mapping) => new()
+    {
+        Id = mapping.Id,
+        AnimationInfoId = mapping.AnimationInfoId,
+        VirtualPath = mapping.VirtualPath,
+        PhysicalPath = mapping.PhysicalPath,
+        FileStore = mapping.FileStore
+    };
+
+    private static Models.StagedFileMapping ToStagedFileMapping(Models.FileMapping mapping) => new()
+    {
+        Id = mapping.Id,
+        AnimationInfoId = mapping.AnimationInfoId,
+        VirtualPath = mapping.VirtualPath,
+        PhysicalPath = mapping.PhysicalPath,
+        FileStore = mapping.FileStore
+    };
 }
diff --git a/SecondDimensionWatcherReDive/Repositories/FileMappingSetReconciler.cs b/SecondDimensionWatcherReDive/Repositories/FileMappingSetReconciler.cs
index 3cccc78..0e5c80d 100644
--- a/SecondDimensionWatcherReDive/Repositories/FileMappingSetReconciler.cs
+++ b/SecondDimensionWatcherReDive/Repositories/FileMappingSetReconciler.cs
@@ -8,27 +8,57 @@ public static async Task<FileMappingReconciliation> ReconcileAsync(
         Models.ApplicationContext context,
         Guid animationInfoId,
         IReadOnlyList<Models.FileMapping> desiredMappings,
+        CancellationToken cancellationToken) =>
+        await ReconcileAcrossOwnersAsync(
+            context,
+            [animationInfoId],
+            desiredMappings,
+            cancellationToken);
+
+    public static async Task<FileMappingReconciliation> CaptureIdentitiesAsync(
+        Models.ApplicationContext context,
+        IReadOnlyList<Models.FileMapping> mappings,
+        CancellationToken cancellationToken)
+    {
+        var identityPaths = mappings
+            .SelectMany(mapping => EnumerateEntryPaths(mapping.VirtualPath))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+        var preservedIdentities = await LoadEntryIdentitiesAsync(
+            context,
+            identityPaths,
+            cancellationToken);
+        return new FileMappingReconciliation(mappings, preservedIdentities);
+    }
+
+    public static async Task<FileMappingReconciliation> ReconcileAcrossOwnersAsync(
+        Models.ApplicationContext context,
+        IReadOnlyCollection<Guid> animationInfoIds,
+        IReadOnlyList<Models.FileMapping> desiredMappings,
         CancellationToken cancellationToken)
     {
+        if (animationInfoIds.Count == 0)
+            throw new ArgumentException("At least one mapping owner is required.", nameof(animationInfoIds));
+        var ownerIds = animationInfoIds.ToHashSet();
+        if (desiredMappings.Any(mapping => !ownerIds.Contains(mapping.AnimationInfoId)))
+            throw new ArgumentException("A desired mapping belongs to an owner outside the reconciliation set.",
+                nameof(desiredMappings));
+
         var desiredByPath = desiredMappings.ToDictionary(
             mapping => mapping.VirtualPath,
             StringComparer.Ordinal);
         var existingMappings = await context.FileMappings
-            .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+            .Where(mapping => ownerIds.Contains(mapping.AnimationInfoId))
             .ToListAsync(cancellationToken);
         var identityPaths = existingMappings
             .SelectMany(mapping => EnumerateEntryPaths(mapping.VirtualPath))
             .Concat(desiredMappings.SelectMany(mapping => EnumerateEntryPaths(mapping.VirtualPath)))
             .Distinct(StringComparer.Ordinal)
             .ToArray();
-        var preservedIdentities = await context.FileSystemEntries
-            .AsNoTracking()
-            .Where(entry => identityPaths.Contains(entry.Path))
-            .ToDictionaryAsync(
-                entry => entry.Path,
-                entry => new FileSystemEntryIdentity(entry.EntryId, entry.IsDirectory),
-                StringComparer.Ordinal,
-                cancellationToken);
+        var preservedIdentities = await LoadEntryIdentitiesAsync(
+            context,
+            identityPaths,
+            cancellationToken);
         var reconciled = new List<Models.FileMapping>(desiredMappings.Count);
         var hasRemovals = false;
 
@@ -41,6 +71,7 @@ public static async Task<FileMappingReconciliation> ReconcileAsync(
                 continue;
             }
 
+            existing.AnimationInfoId = desired.AnimationInfoId;
             existing.PhysicalPath = desired.PhysicalPath;
             existing.FileStore = desired.FileStore;
             reconciled.Add(existing);
@@ -73,6 +104,19 @@ private static IEnumerable<string> EnumerateEntryPaths(string virtualPath)
         for (var slash = virtualPath.LastIndexOf('/'); slash > 0; slash = virtualPath.LastIndexOf('/', slash - 1))
             yield return virtualPath[..slash];
     }
+
+    private static async Task<IReadOnlyDictionary<string, FileSystemEntryIdentity>> LoadEntryIdentitiesAsync(
+        Models.ApplicationContext context,
+        IReadOnlyCollection<string> identityPaths,
+        CancellationToken cancellationToken) =>
+        await context.FileSystemEntries
+            .AsNoTracking()
+            .Where(entry => identityPaths.Contains(entry.Path))
+            .ToDictionaryAsync(
+                entry => entry.Path,
+                entry => new FileSystemEntryIdentity(entry.EntryId, entry.IsDirectory),
+                StringComparer.Ordinal,
+                cancellationToken);
 }
 
 internal sealed record FileMappingReconciliation(
diff --git a/SecondDimensionWatcherReDive/Repositories/LibrarySearchRepository.cs b/SecondDimensionWatcherReDive/Repositories/LibrarySearchRepository.cs
new file mode 100644
index 0000000..2b1072d
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Repositories/LibrarySearchRepository.cs
@@ -0,0 +1,565 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Framework.FileDownload;
+
+namespace SecondDimensionWatcherReDive.Repositories;
+
+public sealed class LibrarySearchRepository(Models.ApplicationContext context)
+    : ILibrarySearchRepository
+{
+    private const int MaximumReturnedPathsPerRelease = 20;
+
+    private sealed record SearchCursor(
+        DateTimeOffset SnapshotUtc,
+        string Signature,
+        long Revision,
+        long? WatchRevision,
+        Guid LastId,
+        DateTimeOffset? PublishedAt,
+        int? Score,
+        string? SortTitle,
+        int? Season,
+        int? Episode);
+
+    private sealed record SearchRow(
+        Guid Id,
+        string Title,
+        string SortTitle,
+        string? AnimationName,
+        string? AnimationOriginalName,
+        string? TmdbId,
+        int? Season,
+        int? Episode,
+        string? ReleaseSubtitleGroup,
+        string? GroupName,
+        string? ReleaseResolution,
+        string? ReleaseCodec,
+        string[] ReleaseLanguages,
+        bool IsDownloadTracked,
+        bool IsDownloadFinished,
+        string DownloadType,
+        int ReleaseScore,
+        string? ReleaseScoreReasonsJson,
+        DateTimeOffset PublishTime);
+
+    private sealed record IntegrityRelease(
+        Guid Id,
+        string TmdbId,
+        string AnimationName,
+        int? Season,
+        int? Episode,
+        int? ExpectedEpisodeCount,
+        bool IsDownloadFinished,
+        bool IsActiveRelease,
+        Guid? DownloadCancellationId,
+        int ReleaseScore,
+        DateTimeOffset PublishTime,
+        Guid? SourceFeedId,
+        string? ReleaseScoreReasonsJson);
+
+    private sealed class MappingPathRow
+    {
+        public Guid AnimationInfoId { get; init; }
+        public string VirtualPath { get; init; } = string.Empty;
+        public long TotalCount { get; init; }
+    }
+
+    public async Task<LibrarySearchResult> SearchAsync(
+        LibrarySearchRequest request,
+        CancellationToken cancellationToken)
+    {
+        if (request.Take is < 1 or > 100)
+            throw new ArgumentOutOfRangeException(nameof(request), "Take must be between 1 and 100.");
+
+        var signature = Signature(request);
+        var cursor = DecodeCursor(request.Cursor);
+        if (cursor is not null && !string.Equals(cursor.Signature, signature, StringComparison.Ordinal))
+            throw new ArgumentException("The search cursor does not match the active filters.", nameof(request));
+        var revision = await ReadLibraryRevisionAsync(cancellationToken);
+        if (cursor is not null && cursor.Revision != revision)
+            throw new ArgumentException("The library changed; restart search pagination.", nameof(request));
+        var watchRevision = await ReadWatchRevisionAsync(
+            request.UserId,
+            request.WatchState,
+            cancellationToken);
+        if (cursor is not null && cursor.WatchRevision != watchRevision)
+            throw new ArgumentException("The playback state changed; restart search pagination.", nameof(request));
+        var snapshot = cursor?.SnapshotUtc ?? DateTimeOffset.UtcNow;
+        if (cursor is not null && cursor.LastId == Guid.Empty)
+            throw new ArgumentException("The search cursor is invalid.", nameof(request));
+
+        var query = context.AnimationInfo
+            .AsNoTracking()
+            .Where(info => info.MediaLibraryMissingSince == null && info.IngestedAt <= snapshot);
+
+        if (!string.IsNullOrWhiteSpace(request.Query))
+        {
+            var pattern = ContainsPattern(request.Query);
+            query = query.Where(info =>
+                EF.Functions.ILike(info.Title, pattern, "\\") ||
+                EF.Functions.ILike(info.Description, pattern, "\\") ||
+                (info.Animation != null &&
+                 (EF.Functions.ILike(info.Animation.Name, pattern, "\\") ||
+                  EF.Functions.ILike(info.Animation.OriginalName, pattern, "\\") ||
+                  EF.Functions.ILike(info.Animation.TmdbId, pattern, "\\"))) ||
+                (info.Group != null && EF.Functions.ILike(info.Group.Name, pattern, "\\")) ||
+                context.FileMappings.Any(mapping =>
+                    mapping.AnimationInfoId == info.Id &&
+                    EF.Functions.ILike(mapping.VirtualPath, pattern, "\\")));
+        }
+
+        if (request.Season is { } season) query = query.Where(info => info.Season == season);
+        if (request.Episode is { } episode) query = query.Where(info => info.Episode == episode);
+        if (!string.IsNullOrWhiteSpace(request.SubtitleGroup))
+            query = query.Where(info =>
+                info.ReleaseSubtitleGroup == request.SubtitleGroup ||
+                (info.ReleaseSubtitleGroup == null && info.Group != null &&
+                 info.Group.Name == request.SubtitleGroup));
+        if (!string.IsNullOrWhiteSpace(request.Resolution))
+            query = query.Where(info => info.ReleaseResolution == request.Resolution);
+        if (!string.IsNullOrWhiteSpace(request.Codec))
+            query = query.Where(info => info.ReleaseCodec == request.Codec);
+        if (!string.IsNullOrWhiteSpace(request.Language))
+            query = query.Where(info => info.ReleaseLanguages.Contains(request.Language));
+        if (!string.IsNullOrWhiteSpace(request.VirtualPath))
+        {
+            var pathPattern = ContainsPattern(request.VirtualPath);
+            query = query.Where(info => context.FileMappings.Any(mapping =>
+                mapping.AnimationInfoId == info.Id &&
+                EF.Functions.ILike(mapping.VirtualPath, pathPattern, "\\")));
+        }
+
+        query = request.DownloadState switch
+        {
+            LibraryDownloadState.NotDownloaded => query.Where(info => !info.IsDownloadTracked),
+            LibraryDownloadState.Downloading => query.Where(info =>
+                info.IsDownloadTracked && !info.IsDownloadFinished),
+            LibraryDownloadState.Downloaded => query.Where(info => info.IsDownloadFinished),
+            _ => query
+        };
+        query = request.Source switch
+        {
+            LibrarySourceKind.Torrent => query.Where(info =>
+                info.DownloadType == FileDownloadTypes.TorrentDownload),
+            LibrarySourceKind.MediaLibraryImport => query.Where(info =>
+                info.DownloadType == FileDownloadTypes.MediaLibraryImport),
+            _ => query
+        };
+        query = request.WatchState switch
+        {
+            LibraryWatchState.Watched => query.Where(info => context.PlaybackProgresses.Any(progress =>
+                progress.UserId == request.UserId && progress.AnimationInfoId == info.Id && progress.IsWatched)),
+            LibraryWatchState.InProgress => query.Where(info => context.PlaybackProgresses.Any(progress =>
+                progress.UserId == request.UserId && progress.AnimationInfoId == info.Id &&
+                !progress.IsWatched && progress.PositionSeconds > 0)),
+            LibraryWatchState.Unwatched => query.Where(info => !context.PlaybackProgresses.Any(progress =>
+                progress.UserId == request.UserId && progress.AnimationInfoId == info.Id &&
+                (progress.IsWatched || progress.PositionSeconds > 0))),
+            _ => query
+        };
+
+        if (cursor is not null)
+            query = SeekAfter(query, request.Sort, cursor);
+
+        var ordered = request.Sort switch
+        {
+            LibrarySearchSort.TitleAscending => query
+                .OrderBy(info => info.Animation == null ? info.Title : info.Animation.Name)
+                .ThenBy(info => info.Season ?? int.MaxValue)
+                .ThenBy(info => info.Episode ?? int.MaxValue)
+                .ThenBy(info => info.Id),
+            LibrarySearchSort.EpisodeAscending => query
+                .OrderBy(info => info.Season ?? int.MaxValue)
+                .ThenBy(info => info.Episode ?? int.MaxValue)
+                .ThenBy(info => info.Animation == null ? info.Title : info.Animation.Name)
+                .ThenBy(info => info.Id),
+            LibrarySearchSort.ScoreDescending => query
+                .OrderByDescending(info => info.ReleaseScore)
+                .ThenByDescending(info => info.PublishTime)
+                .ThenByDescending(info => info.Id),
+            _ => query
+                .OrderByDescending(info => info.PublishTime)
+                .ThenByDescending(info => info.Id)
+        };
+
+        var page = await ordered
+            .Select(info => new SearchRow(
+                info.Id,
+                info.Title,
+                info.Animation == null ? info.Title : info.Animation.Name,
+                info.Animation == null ? null : info.Animation.Name,
+                info.Animation == null ? null : info.Animation.OriginalName,
+                info.Animation == null ? null : info.Animation.TmdbId,
+                info.Season,
+                info.Episode,
+                info.ReleaseSubtitleGroup,
+                info.Group == null ? null : info.Group.Name,
+                info.ReleaseResolution,
+                info.ReleaseCodec,
+                info.ReleaseLanguages,
+                info.IsDownloadTracked,
+                info.IsDownloadFinished,
+                info.DownloadType,
+                info.ReleaseScore,
+                info.ReleaseScoreReasonsJson,
+                info.PublishTime))
+            .Take(request.Take + 1)
+            .ToListAsync(cancellationToken);
+        var hasMore = page.Count > request.Take;
+        if (hasMore) page.RemoveAt(page.Count - 1);
+        var ids = page.Select(info => info.Id).ToArray();
+        var mappingRows = ids.Length == 0
+            ? []
+            : await context.Database.SqlQuery<MappingPathRow>(
+                    $"""
+                     SELECT ranked."AnimationInfoId", ranked."VirtualPath", ranked."TotalCount"
+                     FROM (
+                         SELECT mapping."AnimationInfoId",
+                                mapping."VirtualPath",
+                                count(*) OVER (
+                                    PARTITION BY mapping."AnimationInfoId") AS "TotalCount",
+                                row_number() OVER (
+                                    PARTITION BY mapping."AnimationInfoId"
+                                    ORDER BY mapping."VirtualPath", mapping."Id") AS "RowNumber"
+                         FROM "FileMappings" AS mapping
+                         WHERE mapping."AnimationInfoId" = ANY ({ids})
+                     ) AS ranked
+                     WHERE ranked."RowNumber" <= {MaximumReturnedPathsPerRelease}
+                     ORDER BY ranked."AnimationInfoId", ranked."VirtualPath"
+                     """)
+                .ToListAsync(cancellationToken);
+        var mappingsByRelease = mappingRows
+            .GroupBy(mapping => mapping.AnimationInfoId)
+            .ToDictionary(
+                group => group.Key,
+                group => group.Select(item => item.VirtualPath).ToList());
+        var mappingCountsByRelease = mappingRows
+            .GroupBy(mapping => mapping.AnimationInfoId)
+            .ToDictionary(group => group.Key, group => group.First().TotalCount);
+        var progressByRelease = (await context.PlaybackProgresses.AsNoTracking()
+                .Where(progress => progress.UserId == request.UserId && ids.Contains(progress.AnimationInfoId))
+                .OrderByDescending(progress => progress.UpdatedAt)
+                .ToListAsync(cancellationToken))
+            .GroupBy(progress => progress.AnimationInfoId)
+            .ToDictionary(group => group.Key, group => group.ToList());
+
+        var items = page.Select(info =>
+        {
+            var progress = progressByRelease.GetValueOrDefault(info.Id) ?? [];
+            return new LibrarySearchItem(
+                info.Id,
+                info.Title,
+                info.AnimationName,
+                info.AnimationOriginalName,
+                info.TmdbId,
+                info.Season,
+                info.Episode,
+                info.ReleaseSubtitleGroup ?? info.GroupName,
+                info.ReleaseResolution,
+                info.ReleaseCodec,
+                info.ReleaseLanguages,
+                info.IsDownloadTracked,
+                info.IsDownloadFinished,
+                info.DownloadType == FileDownloadTypes.MediaLibraryImport,
+                progress.Any(item => item.IsWatched),
+                progress.Count == 0 ? null : progress.Max(item => item.PositionSeconds),
+                mappingsByRelease.GetValueOrDefault(info.Id) ?? [],
+                mappingCountsByRelease.GetValueOrDefault(info.Id),
+                info.ReleaseScore,
+                ParseReasons(info.ReleaseScoreReasonsJson),
+                info.PublishTime);
+        }).ToList();
+
+        if (await ReadLibraryRevisionAsync(cancellationToken) != revision)
+            throw new ArgumentException("The library changed; restart search pagination.", nameof(request));
+        if (await ReadWatchRevisionAsync(request.UserId, request.WatchState, cancellationToken)
+            != watchRevision)
+            throw new ArgumentException("The playback state changed; restart search pagination.", nameof(request));
+
+        var nextCursor = hasMore
+            ? EncodeCursor(CreateCursor(
+                page[^1],
+                request.Sort,
+                snapshot,
+                signature,
+                revision,
+                watchRevision))
+            : null;
+        return new LibrarySearchResult(items, nextCursor);
+    }
+
+    private static IQueryable<Models.AnimationInfo> SeekAfter(
+        IQueryable<Models.AnimationInfo> query,
+        LibrarySearchSort sort,
+        SearchCursor cursor)
+    {
+        return sort switch
+        {
+            LibrarySearchSort.ScoreDescending when cursor.Score is { } score &&
+                                                       cursor.PublishedAt is { } publishedAt =>
+                query.Where(info => EF.Functions.LessThan(
+                    ValueTuple.Create(info.ReleaseScore, info.PublishTime, info.Id),
+                    ValueTuple.Create(score, publishedAt, cursor.LastId))),
+            LibrarySearchSort.TitleAscending when cursor.SortTitle is { } sortTitle =>
+                query.Where(info => EF.Functions.GreaterThan(
+                    ValueTuple.Create(
+                        info.Animation == null ? info.Title : info.Animation.Name,
+                        info.Season ?? int.MaxValue,
+                        info.Episode ?? int.MaxValue,
+                        info.Id
+                    ),
+                    ValueTuple.Create(
+                        sortTitle,
+                        cursor.Season ?? int.MaxValue,
+                        cursor.Episode ?? int.MaxValue,
+                        cursor.LastId
+                    ))),
+            LibrarySearchSort.EpisodeAscending when cursor.SortTitle is { } sortTitle =>
+                query.Where(info => EF.Functions.GreaterThan(
+                    ValueTuple.Create(
+                        info.Season ?? int.MaxValue,
+                        info.Episode ?? int.MaxValue,
+                        info.Animation == null ? info.Title : info.Animation.Name,
+                        info.Id
+                    ),
+                    ValueTuple.Create(
+                        cursor.Season ?? int.MaxValue,
+                        cursor.Episode ?? int.MaxValue,
+                        sortTitle,
+                        cursor.LastId
+                    ))),
+            LibrarySearchSort.PublishedDescending when cursor.PublishedAt is { } publishedAt =>
+                query.Where(info => EF.Functions.LessThan(
+                    ValueTuple.Create(info.PublishTime, info.Id),
+                    ValueTuple.Create(publishedAt, cursor.LastId))),
+            _ => throw new ArgumentException("The search cursor is invalid.")
+        };
+    }
+
+    private static SearchCursor CreateCursor(
+        SearchRow row,
+        LibrarySearchSort sort,
+        DateTimeOffset snapshot,
+        string signature,
+        long revision,
+        long? watchRevision) =>
+        new(
+            snapshot,
+            signature,
+            revision,
+            watchRevision,
+            row.Id,
+            sort is LibrarySearchSort.PublishedDescending or LibrarySearchSort.ScoreDescending
+                ? row.PublishTime
+                : null,
+            sort == LibrarySearchSort.ScoreDescending ? row.ReleaseScore : null,
+            sort is LibrarySearchSort.TitleAscending or LibrarySearchSort.EpisodeAscending
+                ? row.SortTitle
+                : null,
+            sort is LibrarySearchSort.TitleAscending or LibrarySearchSort.EpisodeAscending
+                ? row.Season
+                : null,
+            sort is LibrarySearchSort.TitleAscending or LibrarySearchSort.EpisodeAscending
+                ? row.Episode
+                : null);
+
+    private async Task<long> ReadLibraryRevisionAsync(CancellationToken cancellationToken) =>
+        await context.AnimationCatalogStates.AsNoTracking()
+            .Where(state => state.Id == 1)
+            .Select(state => state.Revision)
+            .SingleAsync(cancellationToken);
+
+    private async Task<long?> ReadWatchRevisionAsync(
+        Guid userId,
+        LibraryWatchState watchState,
+        CancellationToken cancellationToken)
+    {
+        if (watchState == LibraryWatchState.Any) return null;
+        return await context.PlaybackCatalogStates.AsNoTracking()
+            .Where(state => state.UserId == userId)
+            .Select(state => (long?)state.Revision)
+            .SingleOrDefaultAsync(cancellationToken) ?? 0;
+    }
+
+    public async Task<IReadOnlyList<LibraryIntegritySummary>> GetIntegrityAsync(
+        string? tmdbId,
+        int? season,
+        CancellationToken cancellationToken)
+    {
+        var query = context.AnimationInfo.AsNoTracking()
+            .Where(info => info.Animation != null && info.MediaLibraryMissingSince == null);
+        if (!string.IsNullOrWhiteSpace(tmdbId))
+            query = query.Where(info => info.Animation!.TmdbId == tmdbId);
+        if (season is not null) query = query.Where(info => info.Season == season);
+
+        var releaseIds = query.Select(info => info.Id);
+        var releases = await query
+            .Select(info => new IntegrityRelease(
+                info.Id,
+                info.Animation!.TmdbId,
+                info.Animation.Name,
+                info.Season,
+                info.Episode,
+                info.ExpectedEpisodeCount,
+                info.IsDownloadFinished,
+                info.IsActiveRelease,
+                info.DownloadCancellationId,
+                info.ReleaseScore,
+                info.PublishTime,
+                info.SourceFeedId,
+                info.ReleaseScoreReasonsJson))
+            .ToListAsync(cancellationToken);
+        var mappedIds = await context.FileMappings.AsNoTracking()
+            .Where(mapping => releaseIds.Contains(mapping.AnimationInfoId))
+            .Select(mapping => mapping.AnimationInfoId)
+            .Distinct()
+            .ToHashSetAsync(cancellationToken);
+        var policies = await context.SubscriptionAutomationPolicies.AsNoTracking()
+            .ToDictionaryAsync(policy => policy.FeedId, cancellationToken);
+        var unavailableCandidateIds = await context.ReleaseUpgradeOperations.AsNoTracking()
+            .Where(operation =>
+                releaseIds.Contains(operation.CandidateReleaseId) &&
+                operation.Status != ReleaseUpgradeStatus.Failed)
+            .Select(operation => operation.CandidateReleaseId)
+            .Distinct()
+            .ToHashSetAsync(cancellationToken);
+
+        return releases
+            .Where(info => info.Season is > 0)
+            .GroupBy(info => new
+            {
+                info.TmdbId,
+                info.AnimationName,
+                Season = info.Season!.Value
+            })
+            .Select(group => BuildIntegrity(group, mappedIds, policies, unavailableCandidateIds))
+            .OrderBy(item => item.AnimationName)
+            .ThenBy(item => item.Season)
+            .ToList();
+    }
+
+    private static LibraryIntegritySummary BuildIntegrity(
+        IEnumerable<IntegrityRelease> source,
+        IReadOnlySet<Guid> mappedIds,
+        IReadOnlyDictionary<Guid, Models.SubscriptionAutomationPolicy> policies,
+        IReadOnlySet<Guid> unavailableCandidateIds)
+    {
+        var releases = source.ToList();
+        var first = releases[0];
+        var downloaded = releases
+            .Where(info => info.IsDownloadFinished && mappedIds.Contains(info.Id) && info.Episode is > 0)
+            .ToList();
+        var expected = releases.Max(info => info.ExpectedEpisodeCount);
+        var present = downloaded.Select(info => info.Episode!.Value).ToHashSet();
+        var missing = expected is { } count
+            ? Enumerable.Range(1, count).Where(episode => !present.Contains(episode)).ToList()
+            : [];
+        var duplicates = downloaded
+            .GroupBy(info => info.Episode!.Value)
+            .Where(group => group.Count() > 1)
+            .Select(group => new EpisodeDuplicate(
+                group.Key,
+                group.OrderByDescending(item => item.ReleaseScore).Select(item => item.Id).ToList()))
+            .OrderBy(item => item.Episode)
+            .ToList();
+        var candidates = new List<ReleaseUpgradeCandidate>();
+        foreach (var episodeGroup in releases.Where(info => info.Episode is > 0).GroupBy(info => info.Episode!.Value))
+        {
+            var current = episodeGroup
+                .Where(info => info.IsActiveRelease && info.IsDownloadFinished && mappedIds.Contains(info.Id))
+                .OrderByDescending(info => info.ReleaseScore)
+                .ThenByDescending(info => info.PublishTime)
+                .FirstOrDefault();
+            if (current is null) continue;
+            var candidate = episodeGroup
+                .Where(info =>
+                    !info.IsActiveRelease &&
+                    info.DownloadCancellationId is null &&
+                    !unavailableCandidateIds.Contains(info.Id) &&
+                    info.ReleaseScore > current.ReleaseScore)
+                .OrderByDescending(info => info.ReleaseScore)
+                .ThenByDescending(info => info.PublishTime)
+                .FirstOrDefault();
+            if (candidate is null) continue;
+            var automatic = current.ReleaseScoreReasonsJson is not null &&
+                            candidate.SourceFeedId is { } feedId &&
+                            policies.TryGetValue(feedId, out var policy) &&
+                            policy.EnableVersionUpgrade &&
+                            candidate.ReleaseScore - current.ReleaseScore >= policy.MinimumUpgradeScore;
+            candidates.Add(new ReleaseUpgradeCandidate(
+                current.Id,
+                candidate.Id,
+                first.AnimationName,
+                first.Season!.Value,
+                episodeGroup.Key,
+                current.ReleaseScore,
+                candidate.ReleaseScore,
+                ParseReasons(candidate.ReleaseScoreReasonsJson),
+                automatic));
+        }
+
+        return new LibraryIntegritySummary(
+            first.TmdbId,
+            first.AnimationName,
+            first.Season!.Value,
+            expected,
+            missing,
+            duplicates,
+            releases.Count(info => info.Episode is null),
+            candidates.OrderBy(item => item.Episode).ToList());
+    }
+
+    private static string ContainsPattern(string value) =>
+        $"%{value.Trim().Replace("\\", "\\\\", StringComparison.Ordinal)
+            .Replace("%", "\\%", StringComparison.Ordinal)
+            .Replace("_", "\\_", StringComparison.Ordinal)}%";
+
+    private static IReadOnlyList<string> ParseReasons(string? json)
+    {
+        if (string.IsNullOrWhiteSpace(json)) return [];
+        try
+        {
+            return JsonSerializer.Deserialize<string[]>(json) ?? [];
+        }
+        catch (JsonException)
+        {
+            return [];
+        }
+    }
+
+    private static string Signature(LibrarySearchRequest request)
+    {
+        var value = string.Join('\n',
+            request.Query?.Trim(), request.Season, request.Episode,
+            request.SubtitleGroup, request.Resolution, request.Codec, request.Language,
+            request.DownloadState, request.WatchState, request.VirtualPath,
+            request.Source, request.Sort, request.Take, request.UserId);
+        return Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value)))[..24];
+    }
+
+    private static string EncodeCursor(SearchCursor cursor)
+    {
+        var bytes = JsonSerializer.SerializeToUtf8Bytes(cursor);
+        return Convert.ToBase64String(bytes).TrimEnd('=').Replace('+', '-').Replace('/', '_');
+    }
+
+    private static SearchCursor? DecodeCursor(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return null;
+        if (value.Length > 512) throw new ArgumentException("The search cursor is too long.");
+        try
+        {
+            var normalized = value.Replace('-', '+').Replace('_', '/');
+            normalized = normalized.PadRight((normalized.Length + 3) / 4 * 4, '=');
+            return JsonSerializer.Deserialize<SearchCursor>(Convert.FromBase64String(normalized))
+                   ?? throw new ArgumentException("The search cursor is invalid.");
+        }
+        catch (Exception exception) when (exception is FormatException or JsonException)
+        {
+            throw new ArgumentException("The search cursor is invalid.", exception);
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Repositories/MetadataReviewRepository.cs b/SecondDimensionWatcherReDive/Repositories/MetadataReviewRepository.cs
index c55be0f..6d4b9bf 100644
--- a/SecondDimensionWatcherReDive/Repositories/MetadataReviewRepository.cs
+++ b/SecondDimensionWatcherReDive/Repositories/MetadataReviewRepository.cs
@@ -52,6 +52,17 @@ public async Task<MetadataReviewQueuePage> GetQueueAsync(
                 .GroupBy(mapping => mapping.AnimationInfoId)
                 .Select(group => new { AnimationInfoId = group.Key, Count = group.Count() })
                 .ToDictionaryAsync(row => row.AnimationInfoId, row => row.Count, cancellationToken);
+        if (animationInfoIds.Length > 0)
+        {
+            var stagedCounts = await context.StagedFileMappings
+                .AsNoTracking()
+                .Where(mapping => animationInfoIds.Contains(mapping.AnimationInfoId))
+                .GroupBy(mapping => mapping.AnimationInfoId)
+                .Select(group => new { AnimationInfoId = group.Key, Count = group.Count() })
+                .ToListAsync(cancellationToken);
+            foreach (var row in stagedCounts)
+                mappingCounts[row.AnimationInfoId] = mappingCounts.GetValueOrDefault(row.AnimationInfoId) + row.Count;
+        }
 
         var operationIds = entities
             .Where(info => info.CurrentMetadataReviewOperationId.HasValue)
@@ -227,11 +238,10 @@ public async Task<MetadataReviewMutationResult> ApplyPreviewAsync(
                     return Failure(MetadataReviewMutationOutcome.NotFound, operationId);
                 if (operation.State == MetadataReviewOperationState.Applied)
                 {
-                    var currentMappings = await applyContext.FileMappings
-                        .AsNoTracking()
-                        .Where(mapping => mapping.AnimationInfoId == animationInfo.Id)
-                        .OrderBy(mapping => mapping.VirtualPath)
-                        .ToListAsync(cancellationToken);
+                    var currentMappings = await LoadOwnedMappingsAsync(
+                        applyContext,
+                        animationInfo.Id,
+                        cancellationToken);
                     var appliedSnapshots = operation.MappingSnapshots
                         .Where(snapshot => snapshot.Kind == MetadataReviewMappingKind.Proposed)
                         .ToList();
@@ -295,14 +305,17 @@ public async Task<MetadataReviewMutationResult> ApplyPreviewAsync(
                         operationId,
                         animationInfo.Id);
 
-                var existingMappings = await applyContext.FileMappings
-                    .AsNoTracking()
-                    .Where(mapping => mapping.AnimationInfoId == animationInfo.Id)
-                    .OrderBy(mapping => mapping.VirtualPath)
-                    .ToListAsync(cancellationToken);
+                var existingMappings = await LoadOwnedMappingsAsync(
+                    applyContext,
+                    animationInfo.Id,
+                    cancellationToken);
                 var mappingsBefore = existingMappings.Select(mapping => mapping.ToRecord()).ToList();
 
                 var animationInfoEntry = applyContext.Entry(animationInfo);
+                var previousEpisodeIdentity = AnimationInfoRepository.GetEpisodeIdentity(
+                    applyContext,
+                    animationInfo);
+                var wasActiveRelease = animationInfo.IsActiveRelease;
                 operation.PreviousDescription = animationInfo.Description;
                 operation.PreviousAnimationId = animationInfoEntry
                     .Property<Guid?>("AnimationId")
@@ -351,6 +364,8 @@ await applyContext.TodoItemStates
                 animationInfo.Description = operation.ProposedDescription;
                 animationInfo.Animation = animation;
                 animationInfo.Group = group;
+                animationInfoEntry.Property<Guid?>("AnimationId").CurrentValue = animation.Id;
+                animationInfoEntry.Property<Guid?>("GroupId").CurrentValue = group?.Id;
                 animationInfo.Season = operation.ProposedSeason;
                 animationInfo.Episode = operation.ProposedEpisode;
                 animationInfo.MetadataStatus = MetadataReviewStatus.Reviewed;
@@ -360,6 +375,16 @@ await applyContext.TodoItemStates
                 animationInfo.AiRetryCount = 0;
                 animationInfo.MetadataReviewedAt = appliedAt;
                 animationInfo.CurrentMetadataReviewOperationId = operation.Id;
+                await AnimationInfoRepository.SetEpisodeReleaseActivityAsync(
+                    applyContext,
+                    animationInfo,
+                    willHaveMappings: proposedSnapshots.Count > 0,
+                    cancellationToken);
+                var currentEpisodeIdentity = animationInfo.IsActiveRelease
+                    ? AnimationInfoRepository.GetEpisodeIdentity(applyContext, animationInfo)
+                    : null;
+                var shouldStage = currentEpisodeIdentity is null &&
+                                  AnimationInfoRepository.GetEpisodeIdentity(applyContext, animationInfo) is not null;
                 animationInfo.StateVersion = checked(animationInfo.StateVersion + 1);
 
                 var desiredMappings = proposedSnapshots
@@ -381,9 +406,14 @@ await PlaybackProgressMappingMigrator.MigrateAsync(
                 var reconciliation = await FileMappingSetReconciler.ReconcileAsync(
                     applyContext,
                     animationInfo.Id,
-                    desiredMappings,
+                    shouldStage ? [] : desiredMappings,
                     cancellationToken);
-                var replacementMappings = reconciliation.Mappings;
+                await ReplaceStagedMappingsAsync(
+                    applyContext,
+                    animationInfo.Id,
+                    shouldStage ? desiredMappings : [],
+                    cancellationToken);
+                var replacementMappings = desiredMappings;
 
                 operation.State = MetadataReviewOperationState.Applied;
                 operation.AppliedAt = appliedAt;
@@ -391,6 +421,15 @@ await PlaybackProgressMappingMigrator.MigrateAsync(
                 operation.AppliedVersion = animationInfo.StateVersion;
 
                 await applyContext.SaveChangesAsync(cancellationToken);
+                await AnimationInfoRepository.PromotePreviousEpisodeSuccessorAsync(
+                    applyContext,
+                    animationInfo.Id,
+                    wasActiveRelease,
+                    previousEpisodeIdentity,
+                    currentEpisodeIdentity,
+                    existingMappings,
+                    retainChangedReleaseMappings: true,
+                    cancellationToken);
                 await reconciliation.RestoreEntryIdentitiesAsync(
                     applyContext,
                     cancellationToken);
@@ -447,11 +486,10 @@ public async Task<MetadataReviewMutationResult> UndoAsync(
                     return Failure(MetadataReviewMutationOutcome.NotFound, operationId);
                 if (operation.State == MetadataReviewOperationState.Undone)
                 {
-                    var idempotentCurrentMappings = await undoContext.FileMappings
-                        .AsNoTracking()
-                        .Where(mapping => mapping.AnimationInfoId == animationInfo.Id)
-                        .OrderBy(mapping => mapping.VirtualPath)
-                        .ToListAsync(cancellationToken);
+                    var idempotentCurrentMappings = await LoadOwnedMappingsAsync(
+                        undoContext,
+                        animationInfo.Id,
+                        cancellationToken);
                     var restoredSnapshots = operation.MappingSnapshots
                         .Where(snapshot => snapshot.Kind == MetadataReviewMappingKind.Previous)
                         .ToList();
@@ -492,11 +530,10 @@ public async Task<MetadataReviewMutationResult> UndoAsync(
                         operationId,
                         animationInfo.Id);
 
-                var currentMappings = await undoContext.FileMappings
-                    .AsNoTracking()
-                    .Where(mapping => mapping.AnimationInfoId == animationInfo.Id)
-                    .OrderBy(mapping => mapping.VirtualPath)
-                    .ToListAsync(cancellationToken);
+                var currentMappings = await LoadOwnedMappingsAsync(
+                    undoContext,
+                    animationInfo.Id,
+                    cancellationToken);
                 var proposedSnapshots = operation.MappingSnapshots
                     .Where(snapshot => snapshot.Kind == MetadataReviewMappingKind.Proposed)
                     .ToList();
@@ -567,12 +604,20 @@ public async Task<MetadataReviewMutationResult> UndoAsync(
                             animationInfo.Id);
                 }
 
+                var previousEpisodeIdentity = AnimationInfoRepository.GetEpisodeIdentity(
+                    undoContext,
+                    animationInfo);
+                var wasActiveRelease = animationInfo.IsActiveRelease;
                 await undoContext.TodoItemStates
                     .Where(state => state.Key == "metadata:" + animationInfo.Id)
                     .ExecuteDeleteAsync(cancellationToken);
                 animationInfo.Description = operation.PreviousDescription;
                 animationInfo.Animation = previousAnimation;
                 animationInfo.Group = previousGroup;
+                undoContext.Entry(animationInfo).Property<Guid?>("AnimationId").CurrentValue =
+                    previousAnimation?.Id;
+                undoContext.Entry(animationInfo).Property<Guid?>("GroupId").CurrentValue =
+                    previousGroup?.Id;
                 animationInfo.Season = operation.PreviousSeason;
                 animationInfo.Episode = operation.PreviousEpisode;
                 animationInfo.MetadataStatus = operation.PreviousMetadataStatus.Value;
@@ -582,6 +627,16 @@ await undoContext.TodoItemStates
                 animationInfo.AiRetryCount = operation.PreviousAiRetryCount.Value;
                 animationInfo.MetadataReviewedAt = operation.PreviousReviewedAt;
                 animationInfo.CurrentMetadataReviewOperationId = operation.PreviousCurrentOperationId;
+                await AnimationInfoRepository.SetEpisodeReleaseActivityAsync(
+                    undoContext,
+                    animationInfo,
+                    willHaveMappings: previousSnapshots.Count > 0,
+                    cancellationToken);
+                var currentEpisodeIdentity = animationInfo.IsActiveRelease
+                    ? AnimationInfoRepository.GetEpisodeIdentity(undoContext, animationInfo)
+                    : null;
+                var shouldStage = currentEpisodeIdentity is null &&
+                                  AnimationInfoRepository.GetEpisodeIdentity(undoContext, animationInfo) is not null;
                 animationInfo.StateVersion = checked(animationInfo.StateVersion + 1);
 
                 var desiredMappings = previousSnapshots
@@ -603,9 +658,14 @@ await PlaybackProgressMappingMigrator.MigrateAsync(
                 var reconciliation = await FileMappingSetReconciler.ReconcileAsync(
                     undoContext,
                     animationInfo.Id,
-                    desiredMappings,
+                    shouldStage ? [] : desiredMappings,
+                    cancellationToken);
+                await ReplaceStagedMappingsAsync(
+                    undoContext,
+                    animationInfo.Id,
+                    shouldStage ? desiredMappings : [],
                     cancellationToken);
-                var restoredMappings = reconciliation.Mappings;
+                var restoredMappings = desiredMappings;
 
                 var undoneAt = DateTimeOffset.UtcNow;
                 operation.State = MetadataReviewOperationState.Undone;
@@ -618,6 +678,15 @@ await PlaybackProgressMappingMigrator.MigrateAsync(
                     previousOperation.AppliedVersion = animationInfo.StateVersion;
 
                 await undoContext.SaveChangesAsync(cancellationToken);
+                await AnimationInfoRepository.PromotePreviousEpisodeSuccessorAsync(
+                    undoContext,
+                    animationInfo.Id,
+                    wasActiveRelease,
+                    previousEpisodeIdentity,
+                    currentEpisodeIdentity,
+                    currentMappings,
+                    retainChangedReleaseMappings: true,
+                    cancellationToken);
                 await reconciliation.RestoreEntryIdentitiesAsync(
                     undoContext,
                     cancellationToken);
@@ -691,6 +760,57 @@ ON CONFLICT ("Name") DO NOTHING
             .SingleAsync(group => group.Name == proposedGroupName, cancellationToken);
     }
 
+    private static async Task<List<Models.FileMapping>> LoadOwnedMappingsAsync(
+        Models.ApplicationContext operationContext,
+        Guid animationInfoId,
+        CancellationToken cancellationToken)
+    {
+        var liveMappings = await operationContext.FileMappings
+            .AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+            .ToListAsync(cancellationToken);
+        var stagedMappings = await operationContext.StagedFileMappings
+            .AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+            .Select(mapping => new Models.FileMapping
+            {
+                Id = mapping.Id,
+                AnimationInfoId = mapping.AnimationInfoId,
+                VirtualPath = mapping.VirtualPath,
+                PhysicalPath = mapping.PhysicalPath,
+                FileStore = mapping.FileStore
+            })
+            .ToListAsync(cancellationToken);
+        return liveMappings
+            .Concat(stagedMappings)
+            .OrderBy(mapping => mapping.VirtualPath, StringComparer.Ordinal)
+            .ToList();
+    }
+
+    private static async Task ReplaceStagedMappingsAsync(
+        Models.ApplicationContext operationContext,
+        Guid animationInfoId,
+        IReadOnlyList<Models.FileMapping> desiredMappings,
+        CancellationToken cancellationToken)
+    {
+        var existingMappings = await operationContext.StagedFileMappings
+            .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+            .ToListAsync(cancellationToken);
+        operationContext.StagedFileMappings.RemoveRange(existingMappings);
+        if (desiredMappings.Count == 0) return;
+
+        await operationContext.StagedFileMappings.AddRangeAsync(
+            desiredMappings.Select(mapping => new Models.StagedFileMapping
+            {
+                Id = mapping.Id,
+                AnimationInfoId = mapping.AnimationInfoId,
+                VirtualPath = mapping.VirtualPath,
+                PhysicalPath = mapping.PhysicalPath,
+                FileStore = mapping.FileStore
+            }),
+            cancellationToken);
+    }
+
     private static bool MappingSetsMatch(
         IReadOnlyList<Models.FileMapping> mappings,
         IReadOnlyList<Models.MetadataReviewMappingSnapshot> snapshots)
diff --git a/SecondDimensionWatcherReDive/Repositories/ReleaseUpgradeRepository.cs b/SecondDimensionWatcherReDive/Repositories/ReleaseUpgradeRepository.cs
new file mode 100644
index 0000000..a96cb0a
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Repositories/ReleaseUpgradeRepository.cs
@@ -0,0 +1,1344 @@
+using System.Text.RegularExpressions;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Utils.FileStore;
+
+namespace SecondDimensionWatcherReDive.Repositories;
+
+public sealed partial class ReleaseUpgradeRepository(
+    Models.ApplicationContext context,
+    DbContextOptions<Models.ApplicationContext> contextOptions) : IReleaseUpgradeRepository
+{
+    private sealed record CandidateRow(
+        Guid CurrentReleaseId,
+        Guid CandidateReleaseId,
+        string AnimationName,
+        int? Season,
+        int? Episode,
+        int CurrentScore,
+        int CandidateScore,
+        DateTimeOffset CandidatePublishTime,
+        string? ReleaseScoreReasonsJson,
+        bool Automatic);
+
+    public async Task<IReadOnlyList<ReleaseUpgradeCandidate>> GetCandidatesAsync(
+        bool automaticOnly,
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200)
+            throw new ArgumentOutOfRangeException(nameof(take));
+
+        var now = DateTimeOffset.UtcNow;
+        var eligibleCandidates = BuildEligibleCandidates(automaticOnly);
+        var candidatePairs =
+            from current in context.AnimationInfo.AsNoTracking()
+            from candidate in eligibleCandidates
+            let automatic = current.ReleaseScoreReasonsJson != null &&
+                            candidate.SourceFeedId != null &&
+                            context.SubscriptionAutomationPolicies.Any(policy =>
+                                policy.FeedId == candidate.SourceFeedId &&
+                                policy.EnableVersionUpgrade &&
+                                candidate.ReleaseScore - current.ReleaseScore >=
+                                policy.MinimumUpgradeScore)
+            where current.IsActiveRelease &&
+                  current.IsDownloadFinished &&
+                  current.DownloadCancellationId == null &&
+                  current.MediaLibraryMissingSince == null &&
+                  current.Animation != null &&
+                  current.Season != null &&
+                  current.Episode != null &&
+                  context.FileMappings.Any(mapping => mapping.AnimationInfoId == current.Id) &&
+                  !context.ReleaseUpgradeOperations.Any(operation =>
+                      operation.CandidateReleaseId == current.Id &&
+                      operation.Status == ReleaseUpgradeStatus.Applied &&
+                      (operation.RollbackUntil == null || operation.RollbackUntil > now)) &&
+                  EF.Property<Guid?>(candidate, "AnimationId") ==
+                  EF.Property<Guid?>(current, "AnimationId") &&
+                  candidate.Season == current.Season &&
+                  candidate.Episode == current.Episode &&
+                  candidate.ReleaseScore > current.ReleaseScore &&
+                  (!automaticOnly || automatic)
+            select new
+            {
+                CurrentReleaseId = current.Id,
+                CandidateReleaseId = candidate.Id,
+                AnimationName = current.Animation!.Name,
+                current.Season,
+                current.Episode,
+                CurrentScore = current.ReleaseScore,
+                CandidateScore = candidate.ReleaseScore,
+                CandidatePublishTime = candidate.PublishTime,
+                candidate.ReleaseScoreReasonsJson,
+                Automatic = automatic
+            };
+
+        // Rank only candidates that are actually eligible for this scan. In
+        // particular, an ineligible higher-scored release must not hide a lower
+        // release whose source policy permits automatic upgrades.
+        var bestCandidateIds = candidatePairs
+            .GroupBy(pair => pair.CurrentReleaseId)
+            .Select(group => group
+                .OrderByDescending(pair => pair.CandidateScore)
+                .ThenByDescending(pair => pair.CandidatePublishTime)
+                .ThenBy(pair => pair.CandidateReleaseId)
+                .Select(pair => pair.CandidateReleaseId)
+                .First());
+        var rows = await candidatePairs
+            .Where(pair => bestCandidateIds.Contains(pair.CandidateReleaseId))
+            .OrderByDescending(pair => pair.CandidateScore - pair.CurrentScore)
+            .ThenBy(pair => pair.AnimationName)
+            .ThenBy(pair => pair.Season)
+            .ThenBy(pair => pair.Episode)
+            .ThenBy(pair => pair.CandidateReleaseId)
+            .Take(take)
+            .ToListAsync(cancellationToken);
+        return rows.Select(row => new ReleaseUpgradeCandidate(
+                row.CurrentReleaseId,
+                row.CandidateReleaseId,
+                row.AnimationName,
+                row.Season.GetValueOrDefault(),
+                row.Episode.GetValueOrDefault(),
+                row.CurrentScore,
+                row.CandidateScore,
+                ParseReasons(row.ReleaseScoreReasonsJson),
+                row.Automatic))
+            .ToList();
+    }
+
+    public async Task<ReleaseUpgradeCandidate?> FindCandidateAsync(
+        Guid currentReleaseId,
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var row = await BuildCandidatePairs(
+                automaticOnly: false,
+                DateTimeOffset.UtcNow,
+                currentReleaseId,
+                candidateReleaseId)
+            .SingleOrDefaultAsync(cancellationToken);
+        return row is null ? null : ToCandidate(row);
+    }
+
+    private IQueryable<CandidateRow> BuildCandidatePairs(
+        bool automaticOnly,
+        DateTimeOffset now,
+        Guid? currentReleaseId = null,
+        Guid? candidateReleaseId = null)
+    {
+        var currentReleases = context.AnimationInfo.AsNoTracking();
+        if (currentReleaseId is { } currentId)
+            currentReleases = currentReleases.Where(release => release.Id == currentId);
+
+        var eligibleCandidates = BuildEligibleCandidates(automaticOnly);
+        if (candidateReleaseId is { } candidateId)
+            eligibleCandidates = eligibleCandidates.Where(release => release.Id == candidateId);
+
+        var candidatePairs =
+            from current in currentReleases
+            from candidate in eligibleCandidates
+            let automatic = current.ReleaseScoreReasonsJson != null &&
+                            candidate.SourceFeedId != null &&
+                            context.SubscriptionAutomationPolicies.Any(policy =>
+                                policy.FeedId == candidate.SourceFeedId &&
+                                policy.EnableVersionUpgrade &&
+                                candidate.ReleaseScore - current.ReleaseScore >=
+                                policy.MinimumUpgradeScore)
+            where current.IsActiveRelease &&
+                  current.IsDownloadFinished &&
+                  current.DownloadCancellationId == null &&
+                  current.MediaLibraryMissingSince == null &&
+                  current.Animation != null &&
+                  current.Season != null &&
+                  current.Episode != null &&
+                  context.FileMappings.Any(mapping => mapping.AnimationInfoId == current.Id) &&
+                  !context.ReleaseUpgradeOperations.Any(operation =>
+                      operation.CandidateReleaseId == current.Id &&
+                      operation.Status == ReleaseUpgradeStatus.Applied &&
+                      (operation.RollbackUntil == null || operation.RollbackUntil > now)) &&
+                  EF.Property<Guid?>(candidate, "AnimationId") ==
+                  EF.Property<Guid?>(current, "AnimationId") &&
+                  candidate.Season == current.Season &&
+                  candidate.Episode == current.Episode &&
+                  candidate.ReleaseScore > current.ReleaseScore &&
+                  (!automaticOnly || automatic)
+            select new CandidateRow(
+                current.Id,
+                candidate.Id,
+                current.Animation!.Name,
+                current.Season,
+                current.Episode,
+                current.ReleaseScore,
+                candidate.ReleaseScore,
+                candidate.PublishTime,
+                candidate.ReleaseScoreReasonsJson,
+                automatic);
+        return candidatePairs;
+    }
+
+    private IQueryable<Models.AnimationInfo> BuildEligibleCandidates(bool automaticOnly)
+    {
+        var query = context.AnimationInfo.AsNoTracking()
+            .Where(candidate =>
+                !candidate.IsActiveRelease &&
+                candidate.MediaLibraryMissingSince == null &&
+                candidate.Season != null &&
+                candidate.Episode != null &&
+                candidate.DownloadCancellationId == null);
+        return automaticOnly
+            ? query.Where(candidate => !context.ReleaseUpgradeOperations.Any(operation =>
+                operation.CandidateReleaseId == candidate.Id))
+            : query.Where(candidate => !context.ReleaseUpgradeOperations.Any(operation =>
+                operation.CandidateReleaseId == candidate.Id &&
+                operation.Status != ReleaseUpgradeStatus.Failed));
+    }
+
+    private static ReleaseUpgradeCandidate ToCandidate(CandidateRow row) => new(
+        row.CurrentReleaseId,
+        row.CandidateReleaseId,
+        row.AnimationName,
+        row.Season.GetValueOrDefault(),
+        row.Episode.GetValueOrDefault(),
+        row.CurrentScore,
+        row.CandidateScore,
+        ParseReasons(row.ReleaseScoreReasonsJson),
+        row.Automatic);
+
+    public async Task<ReleaseUpgradeOperation?> TryBeginAsync(
+        ReleaseUpgradeCandidate candidate,
+        DateTimeOffset createdAt,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var releases = await MappingTransactionLock.LockAnimationInfosAsync(
+                writeContext,
+                [candidate.CurrentReleaseId, candidate.CandidateReleaseId],
+                cancellationToken);
+            if (!releases.TryGetValue(candidate.CurrentReleaseId, out var current) ||
+                !releases.TryGetValue(candidate.CandidateReleaseId, out var next))
+                return null;
+            await writeContext.Entry(current).Reference(info => info.Animation).LoadAsync(cancellationToken);
+            await writeContext.Entry(next).Reference(info => info.Animation).LoadAsync(cancellationToken);
+            // An in-flight download that predates this operation is owned by
+            // its original submitter. Waiting for it to finish avoids making
+            // upgrade recovery race that submitter's compensation path.
+            if (current.Animation is null || next.Animation is null ||
+                current.Animation.Id != next.Animation.Id ||
+                current.Season != next.Season ||
+                current.Episode != next.Episode ||
+                next.ReleaseScore <= current.ReleaseScore ||
+                !current.IsActiveRelease ||
+                next.IsActiveRelease ||
+                current.DownloadCancellationId is not null ||
+                current.MediaLibraryMissingSince is not null ||
+                next.MediaLibraryMissingSince is not null ||
+                (next.IsDownloadTracked && !next.IsDownloadFinished) ||
+                next.DownloadCancellationId is not null ||
+                !current.IsDownloadFinished ||
+                !await writeContext.FileMappings.AnyAsync(
+                    mapping => mapping.AnimationInfoId == current.Id,
+                    cancellationToken))
+                return null;
+
+            // Rows created before release scoring was introduced have no score
+            // provenance. Keep them available for an explicit manual replacement,
+            // but never let an automatic worker compare a newly scored candidate
+            // against their placeholder zero.
+            if (candidate.Automatic &&
+                (current.ReleaseScoreReasonsJson is null ||
+                 next.SourceFeedId is not { } sourceFeedId ||
+                 !await writeContext.SubscriptionAutomationPolicies.AnyAsync(
+                     policy => policy.FeedId == sourceFeedId &&
+                               policy.EnableVersionUpgrade &&
+                               next.ReleaseScore - current.ReleaseScore >= policy.MinimumUpgradeScore,
+                     cancellationToken)))
+                return null;
+
+            await writeContext.ReleaseUpgradeOperations
+                .Where(operation => operation.Status == ReleaseUpgradeStatus.Applied &&
+                                    operation.RollbackUntil <= createdAt)
+                .ExecuteUpdateAsync(
+                    setters => setters
+                        .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Completed)
+                        .SetProperty(operation => operation.CompletedAt, createdAt),
+                    cancellationToken);
+            if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation => operation.CandidateReleaseId == current.Id &&
+                                 operation.Status == ReleaseUpgradeStatus.Applied,
+                    cancellationToken))
+                return null;
+
+            if (await writeContext.ReleaseUpgradeOperations.AnyAsync(
+                    operation => (operation.CandidateReleaseId == next.Id &&
+                                  operation.Status != ReleaseUpgradeStatus.Failed) ||
+                                 (operation.CurrentReleaseId == current.Id &&
+                                  (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                                   operation.Status == ReleaseUpgradeStatus.Verifying ||
+                                   operation.Status == ReleaseUpgradeStatus.Applied)),
+                    cancellationToken))
+                return null;
+
+            var entity = new Models.ReleaseUpgradeOperation
+            {
+                Id = Guid.NewGuid(),
+                CurrentReleaseId = current.Id,
+                CandidateReleaseId = next.Id,
+                Status = next.IsDownloadFinished
+                    ? ReleaseUpgradeStatus.Verifying
+                    : ReleaseUpgradeStatus.Downloading,
+                CurrentScore = current.ReleaseScore,
+                CandidateScore = next.ReleaseScore,
+                CreatedAt = createdAt
+            };
+            writeContext.ReleaseUpgradeOperations.Add(entity);
+            try
+            {
+                await writeContext.SaveChangesAsync(cancellationToken);
+                await transaction.CommitAsync(cancellationToken);
+                return entity.ToRecord();
+            }
+            catch (DbUpdateException exception) when (exception.InnerException is PostgresException
+            { SqlState: PostgresErrorCodes.UniqueViolation })
+            {
+                return null;
+            }
+        });
+    }
+
+    public async Task<ReleaseUpgradeOperation?> FindActiveByCandidateAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var operation = await context.ReleaseUpgradeOperations.AsNoTracking()
+            .FirstOrDefaultAsync(item => item.CandidateReleaseId == candidateReleaseId &&
+                                         (item.Status == ReleaseUpgradeStatus.Downloading ||
+                                          item.Status == ReleaseUpgradeStatus.Verifying),
+                cancellationToken);
+        return operation?.ToRecord();
+    }
+
+    public async Task<ReleaseUpgradeOperation?> FindByIdAsync(
+        Guid id,
+        CancellationToken cancellationToken)
+    {
+        var operation = await context.ReleaseUpgradeOperations.AsNoTracking()
+            .SingleOrDefaultAsync(item => item.Id == id, cancellationToken);
+        return operation?.ToRecord();
+    }
+
+    public async Task<IReadOnlyList<Guid>> GetReadyCandidateIdsAsync(
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200) throw new ArgumentOutOfRangeException(nameof(take));
+        var databaseNow = await context.Database
+            .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+            .SingleAsync(cancellationToken);
+        return await context.ReleaseUpgradeOperations.AsNoTracking()
+            .Where(operation =>
+                (operation.Status == ReleaseUpgradeStatus.Downloading ||
+                 operation.Status == ReleaseUpgradeStatus.Verifying) &&
+                ((operation.CandidateRelease.IsDownloadFinished &&
+                  context.StagedFileMappings.Any(mapping =>
+                      mapping.AnimationInfoId == operation.CandidateReleaseId)) ||
+                 (operation.Status == ReleaseUpgradeStatus.Downloading &&
+                  !operation.CandidateRelease.IsDownloadFinished &&
+                  operation.CandidateRelease.DownloadCancellationId == null &&
+                  operation.DownloadSubmittedAt == null &&
+                  (operation.DownloadSubmissionLeaseUntil == null ||
+                   operation.DownloadSubmissionLeaseUntil <= databaseNow))))
+            .OrderBy(operation => operation.CreatedAt)
+            .Select(operation => operation.CandidateReleaseId)
+            .Take(take)
+            .ToListAsync(cancellationToken);
+    }
+
+    public async Task<ReleaseUpgradeDownloadSubmissionLease?> TryClaimDownloadSubmissionAsync(
+        Guid operationId,
+        Guid leaseId,
+        TimeSpan leaseDuration,
+        CancellationToken cancellationToken)
+    {
+        if (leaseDuration <= TimeSpan.Zero || leaseDuration > TimeSpan.FromMinutes(30))
+            throw new ArgumentOutOfRangeException(nameof(leaseDuration));
+
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null ||
+                operation.Status != ReleaseUpgradeStatus.Downloading ||
+                operation.DownloadSubmittedAt is not null)
+                return null;
+
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            if (operation.DownloadSubmissionLeaseId == leaseId &&
+                operation.DownloadSubmissionLeaseUntil > databaseNow)
+                return new ReleaseUpgradeDownloadSubmissionLease(
+                    leaseId,
+                    operation.DownloadSubmissionLeaseUntil.Value,
+                    operation.DownloadPreparedAt is not null);
+            if (operation.DownloadSubmissionLeaseUntil > databaseNow)
+                return null;
+
+            var leaseUntil = databaseNow.Add(leaseDuration);
+            operation.DownloadSubmissionLeaseId = leaseId;
+            operation.DownloadSubmissionLeaseUntil = leaseUntil;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return new ReleaseUpgradeDownloadSubmissionLease(
+                leaseId,
+                leaseUntil,
+                operation.DownloadPreparedAt is not null);
+        });
+    }
+
+    public async Task<bool> TryMarkDownloadPreparedAsync(
+        Guid operationId,
+        Guid leaseId,
+        DateTimeOffset preparedAt,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null ||
+                operation.Status != ReleaseUpgradeStatus.Downloading ||
+                operation.DownloadSubmissionLeaseId != leaseId)
+                return false;
+            if (operation.DownloadPreparedAt is not null)
+                return true;
+
+            operation.DownloadPreparedAt = preparedAt;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return true;
+        });
+    }
+
+    public async Task<ReleaseUpgradeDownloadSubmissionMarkOutcome> TryMarkDownloadSubmittedAsync(
+        Guid operationId,
+        Guid leaseId,
+        Guid? downloadAttemptId,
+        DateTimeOffset submittedAt,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null)
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.NotFound;
+            if (operation.Status is ReleaseUpgradeStatus.Verifying or
+                ReleaseUpgradeStatus.Applied or
+                ReleaseUpgradeStatus.Completed or
+                ReleaseUpgradeStatus.RolledBack)
+            {
+                if (operation.DownloadSubmissionLeaseId == leaseId)
+                {
+                    operation.DownloadSubmissionLeaseId = null;
+                    operation.DownloadSubmissionLeaseUntil = null;
+                    await writeContext.SaveChangesAsync(cancellationToken);
+                    await transaction.CommitAsync(cancellationToken);
+                }
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.Settled;
+            }
+            if (operation.Status != ReleaseUpgradeStatus.Downloading)
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.StateChanged;
+            if (operation.DownloadSubmittedAt is not null)
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.AlreadySubmitted;
+            if (operation.DownloadSubmissionLeaseId != leaseId)
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.LeaseLost;
+
+            var candidate = await MappingTransactionLock.LockAnimationInfoAsync(
+                writeContext,
+                operation.CandidateReleaseId,
+                cancellationToken);
+            if (candidate is null ||
+                !candidate.IsDownloadTracked ||
+                candidate.DownloadAttemptId != downloadAttemptId ||
+                candidate.DownloadCancellationId is not null)
+                return ReleaseUpgradeDownloadSubmissionMarkOutcome.StateChanged;
+
+            operation.DownloadSubmittedAt = submittedAt;
+            operation.DownloadSubmissionLeaseId = null;
+            operation.DownloadSubmissionLeaseUntil = null;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return ReleaseUpgradeDownloadSubmissionMarkOutcome.Submitted;
+        });
+    }
+
+    public async Task<IReadOnlyList<ReleaseUpgradePendingDownloadCancellation>>
+        GetPendingDownloadCancellationsAsync(
+            int take,
+            CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200) throw new ArgumentOutOfRangeException(nameof(take));
+        var databaseNow = await context.Database
+            .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+            .SingleAsync(cancellationToken);
+        return await context.ReleaseUpgradeOperations
+            .AsNoTracking()
+            .Where(operation =>
+                (operation.Status == ReleaseUpgradeStatus.Failed ||
+                 operation.Status == ReleaseUpgradeStatus.RolledBack ||
+                 operation.Status == ReleaseUpgradeStatus.Completed) &&
+                operation.DownloadSubmissionLeaseId != null &&
+                operation.CandidateRelease.DownloadCancellationId != null &&
+                (operation.DownloadSubmissionLeaseUntil == null ||
+                 operation.DownloadSubmissionLeaseUntil <= databaseNow))
+            .OrderBy(operation => operation.DownloadSubmissionLeaseUntil)
+            .ThenBy(operation => operation.CreatedAt)
+            .Select(operation => new ReleaseUpgradePendingDownloadCancellation(
+                operation.Id,
+                operation.CandidateReleaseId,
+                operation.DownloadSubmissionLeaseId!.Value,
+                operation.DownloadCancellationRemoveFile))
+            .Take(take)
+            .ToListAsync(cancellationToken);
+    }
+
+    public async Task<int> ClearExpiredDownloadSubmissionLeasesWithoutCancellationAsync(
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database
+                .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            var cleared = await writeContext.ReleaseUpgradeOperations
+                .Where(operation =>
+                    (operation.Status == ReleaseUpgradeStatus.Applied ||
+                     operation.Status == ReleaseUpgradeStatus.Failed ||
+                     operation.Status == ReleaseUpgradeStatus.RolledBack ||
+                     operation.Status == ReleaseUpgradeStatus.Completed) &&
+                    operation.DownloadSubmissionLeaseId != null &&
+                    operation.CandidateRelease.DownloadCancellationId == null &&
+                    (operation.DownloadSubmissionLeaseUntil == null ||
+                     operation.DownloadSubmissionLeaseUntil <= databaseNow))
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(operation => operation.DownloadSubmissionLeaseId, (Guid?)null)
+                        .SetProperty(operation => operation.DownloadSubmissionLeaseUntil,
+                            (DateTimeOffset?)null),
+                    cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return cleared;
+        });
+    }
+
+    public async Task<bool> TryDeferDownloadCancellationAsync(
+        Guid operationId,
+        Guid submissionLeaseId,
+        TimeSpan retryDelay,
+        CancellationToken cancellationToken)
+    {
+        if (retryDelay <= TimeSpan.Zero || retryDelay > TimeSpan.FromMinutes(30))
+            throw new ArgumentOutOfRangeException(nameof(retryDelay));
+
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database
+                .BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null ||
+                operation.Status is not (ReleaseUpgradeStatus.Failed or
+                    ReleaseUpgradeStatus.RolledBack or
+                    ReleaseUpgradeStatus.Completed) ||
+                operation.DownloadSubmissionLeaseId != submissionLeaseId)
+                return false;
+
+            var candidate = await MappingTransactionLock.LockAnimationInfoAsync(
+                writeContext,
+                operation.CandidateReleaseId,
+                cancellationToken);
+            if (candidate?.DownloadCancellationId is null)
+                return false;
+
+            var databaseNow = await writeContext.Database
+                .SqlQueryRaw<DateTimeOffset>("SELECT clock_timestamp() AS \"Value\"")
+                .SingleAsync(cancellationToken);
+            if (operation.DownloadSubmissionLeaseUntil > databaseNow)
+                return true;
+
+            operation.DownloadSubmissionLeaseUntil = databaseNow.Add(retryDelay);
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return true;
+        });
+    }
+
+    public async Task<bool> TryMarkDownloadCancellationReconciledAsync(
+        Guid operationId,
+        Guid submissionLeaseId,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null)
+                return false;
+            if (operation.DownloadSubmissionLeaseId is null)
+                return true;
+            if (operation.Status is not (ReleaseUpgradeStatus.Failed or
+                    ReleaseUpgradeStatus.RolledBack or
+                    ReleaseUpgradeStatus.Completed) ||
+                operation.DownloadSubmissionLeaseId != submissionLeaseId)
+                return false;
+
+            operation.DownloadSubmissionLeaseId = null;
+            operation.DownloadSubmissionLeaseUntil = null;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return true;
+        });
+    }
+
+    public async Task<ReleaseUpgradeActivation?> GetActivationAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var operation = await context.ReleaseUpgradeOperations.AsNoTracking()
+            .FirstOrDefaultAsync(item => item.CandidateReleaseId == candidateReleaseId &&
+                                         (item.Status == ReleaseUpgradeStatus.Downloading ||
+                                          item.Status == ReleaseUpgradeStatus.Verifying),
+                cancellationToken);
+        if (operation is null) return null;
+
+        var previousMappings = await context.FileMappings.AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == operation.CurrentReleaseId)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .ToListAsync(cancellationToken);
+        var candidateMappings = await context.StagedFileMappings.AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == operation.CandidateReleaseId)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .ToListAsync(cancellationToken);
+        return new ReleaseUpgradeActivation(
+            operation.ToRecord(),
+            previousMappings.Select(mapping => mapping.ToRecord()).ToList(),
+            candidateMappings.Select(ToRecord).ToList());
+    }
+
+    public async Task<IReadOnlyList<FileMapping>> GetCandidateMappingsAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken) =>
+        await context.StagedFileMappings.AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == candidateReleaseId)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .Select(mapping => new FileMapping(
+                mapping.Id,
+                mapping.AnimationInfoId,
+                mapping.VirtualPath,
+                mapping.PhysicalPath,
+                mapping.FileStore))
+            .ToListAsync(cancellationToken);
+
+    public async Task<ReleaseUpgradeActivation?> GetRollbackAsync(
+        Guid operationId,
+        CancellationToken cancellationToken)
+    {
+        var operation = await context.ReleaseUpgradeOperations.AsNoTracking()
+            .Include(item => item.MappingSnapshots)
+            .SingleOrDefaultAsync(item => item.Id == operationId &&
+                                          item.Status == ReleaseUpgradeStatus.Applied,
+                cancellationToken);
+        if (operation is null) return null;
+
+        var candidateMappings = await context.FileMappings.AsNoTracking()
+            .Where(mapping => mapping.AnimationInfoId == operation.CandidateReleaseId)
+            .OrderBy(mapping => mapping.VirtualPath)
+            .Select(mapping => mapping.ToRecord())
+            .ToListAsync(cancellationToken);
+        var previousMappings = operation.MappingSnapshots
+            .Where(snapshot => snapshot.Kind == ReleaseUpgradeMappingKind.Previous)
+            .OrderBy(snapshot => snapshot.VirtualPath, StringComparer.Ordinal)
+            .Select(snapshot => FromSnapshot(snapshot).ToRecord())
+            .ToList();
+        return new ReleaseUpgradeActivation(
+            operation.ToRecord(),
+            previousMappings,
+            candidateMappings);
+    }
+
+    public async Task<ReleaseUpgradeMutationResult> ActivateAsync(
+        Guid operationId,
+        IReadOnlyList<FileMapping> expectedPreviousMappings,
+        IReadOnlyList<FileMapping> expectedCandidateMappings,
+        DateTimeOffset verifiedAt,
+        DateTimeOffset rollbackUntil,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .Include(item => item.MappingSnapshots)
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null)
+                return new ReleaseUpgradeMutationResult(false, "not_found", null);
+            if (operation.Status == ReleaseUpgradeStatus.Applied)
+                return new ReleaseUpgradeMutationResult(true, "already_applied", operation.ToRecord());
+            if (operation.Status is not (ReleaseUpgradeStatus.Downloading or ReleaseUpgradeStatus.Verifying))
+                return new ReleaseUpgradeMutationResult(false, "invalid_state", operation.ToRecord());
+
+            var infos = await MappingTransactionLock.LockAnimationInfosAsync(
+                writeContext,
+                [operation.CurrentReleaseId, operation.CandidateReleaseId],
+                cancellationToken);
+            if (!infos.TryGetValue(operation.CurrentReleaseId, out var current) ||
+                !infos.TryGetValue(operation.CandidateReleaseId, out var candidate) ||
+                !candidate.IsDownloadFinished ||
+                current.MediaLibraryMissingSince is not null ||
+                candidate.MediaLibraryMissingSince is not null)
+                return new ReleaseUpgradeMutationResult(false, "candidate_not_ready", operation.ToRecord());
+            if (current.DownloadCancellationId is not null ||
+                candidate.DownloadCancellationId is not null)
+                return new ReleaseUpgradeMutationResult(false, "download_cancelling", operation.ToRecord());
+            if (!AreSameEpisode(writeContext, current, candidate) ||
+                !current.IsActiveRelease ||
+                candidate.IsActiveRelease ||
+                candidate.ReleaseScore <= current.ReleaseScore)
+                return new ReleaseUpgradeMutationResult(false, "release_changed", operation.ToRecord());
+
+            var previous = await writeContext.FileMappings
+                .Where(mapping => mapping.AnimationInfoId == current.Id)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
+            var stagedNext = await writeContext.StagedFileMappings
+                .Where(mapping => mapping.AnimationInfoId == candidate.Id)
+                .OrderBy(mapping => mapping.VirtualPath)
+                .ToListAsync(cancellationToken);
+            var next = stagedNext.Select(ToFileMapping).ToList();
+            if (previous.Count == 0 || next.Count == 0)
+                return new ReleaseUpgradeMutationResult(false, "mapping_missing", operation.ToRecord());
+            if (!MappingSetsMatch(previous, expectedPreviousMappings) ||
+                !MappingSetsMatch(next, expectedCandidateMappings))
+                return new ReleaseUpgradeMutationResult(false, "mapping_changed", operation.ToRecord());
+
+            var snapshots = previous
+                .Select(mapping => ToSnapshot(
+                    operation.Id,
+                    mapping,
+                    ReleaseUpgradeMappingKind.Previous))
+                .Concat(next.Select(mapping => ToSnapshot(
+                    operation.Id,
+                    mapping,
+                    ReleaseUpgradeMappingKind.Candidate)))
+                .ToList();
+            await writeContext.ReleaseUpgradeMappingSnapshots.AddRangeAsync(
+                snapshots,
+                cancellationToken);
+            await SnapshotEntryIdentitiesAsync(
+                writeContext,
+                operation.Id,
+                current.Id,
+                cancellationToken);
+
+            var replacement = BuildCandidateReplacement(previous, next, candidate.Id);
+            var reconciliation = await FileMappingSetReconciler.ReconcileAcrossOwnersAsync(
+                writeContext,
+                [current.Id, candidate.Id],
+                replacement.Mappings,
+                cancellationToken);
+            writeContext.StagedFileMappings.RemoveRange(stagedNext);
+            await TransferPlaybackProgressAsync(
+                writeContext,
+                BuildActivationPlaybackTransfers(current.Id, candidate.Id, replacement),
+                cancellationToken);
+            await writeContext.AnimationInfo
+                .Where(info => info.Id == current.Id)
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(info => info.StateVersion, info => info.StateVersion + 1)
+                        .SetProperty(info => info.IsActiveRelease, false)
+                        .SetProperty(info => info.IsRetiredRelease, true),
+                    cancellationToken);
+            await writeContext.AnimationInfo
+                .Where(info => info.Id == candidate.Id)
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(info => info.StateVersion, info => info.StateVersion + 1)
+                        .SetProperty(info => info.IsActiveRelease, true)
+                        .SetProperty(info => info.IsRetiredRelease, false),
+                    cancellationToken);
+            operation.Status = ReleaseUpgradeStatus.Applied;
+            operation.VerifiedAt = verifiedAt;
+            operation.AppliedAt = verifiedAt;
+            operation.RollbackUntil = rollbackUntil;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await reconciliation.RestoreEntryIdentitiesAsync(writeContext, cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return new ReleaseUpgradeMutationResult(true, "applied", operation.ToRecord());
+        });
+    }
+
+    public async Task<ReleaseUpgradeMutationResult> MarkFailedAsync(
+        Guid operationId,
+        string failureSummary,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            await writeContext.Database.ExecuteSqlInterpolatedAsync(
+                $"SELECT 1 FROM \"ReleaseUpgradeOperations\" WHERE \"Id\" = {operationId} FOR UPDATE",
+                cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null)
+                return new ReleaseUpgradeMutationResult(false, "not_found", null);
+            if (operation.Status == ReleaseUpgradeStatus.Failed)
+                return new ReleaseUpgradeMutationResult(true, "already_failed", operation.ToRecord());
+            if (operation.Status is not (ReleaseUpgradeStatus.Downloading or ReleaseUpgradeStatus.Verifying))
+                return new ReleaseUpgradeMutationResult(false, "invalid_state", operation.ToRecord());
+
+            operation.Status = ReleaseUpgradeStatus.Failed;
+            operation.FailureSummary = failureSummary.Length <= 2048
+                ? failureSummary
+                : failureSummary[..2048];
+            operation.CompletedAt = DateTimeOffset.UtcNow;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return new ReleaseUpgradeMutationResult(true, "failed", operation.ToRecord());
+        });
+    }
+
+    public async Task<ReleaseUpgradeMutationResult> RollbackAsync(
+        Guid operationId,
+        DateTimeOffset rolledBackAt,
+        CancellationToken cancellationToken)
+    {
+        var strategy = context.Database.CreateExecutionStrategy();
+        return await strategy.ExecuteAsync(async () =>
+        {
+            await using var writeContext = new Models.ApplicationContext(contextOptions);
+            await using var transaction = await writeContext.Database.BeginTransactionAsync(cancellationToken);
+            await MappingTransactionLock.AcquireAsync(writeContext, cancellationToken);
+            var operation = await writeContext.ReleaseUpgradeOperations
+                .Include(item => item.MappingSnapshots)
+                .SingleOrDefaultAsync(item => item.Id == operationId, cancellationToken);
+            if (operation is null)
+                return new ReleaseUpgradeMutationResult(false, "not_found", null);
+            if (operation.Status == ReleaseUpgradeStatus.RolledBack)
+                return new ReleaseUpgradeMutationResult(true, "already_rolled_back", operation.ToRecord());
+            if (operation.Status != ReleaseUpgradeStatus.Applied || operation.RollbackUntil < rolledBackAt)
+                return new ReleaseUpgradeMutationResult(false, "rollback_unavailable", operation.ToRecord());
+
+            var infos = await MappingTransactionLock.LockAnimationInfosAsync(
+                writeContext,
+                [operation.CurrentReleaseId, operation.CandidateReleaseId],
+                cancellationToken);
+            if (!infos.TryGetValue(operation.CurrentReleaseId, out var current) ||
+                !infos.TryGetValue(operation.CandidateReleaseId, out var activeCandidate) ||
+                !AreSameEpisode(writeContext, current, activeCandidate) ||
+                current.IsActiveRelease ||
+                !activeCandidate.IsActiveRelease)
+                return new ReleaseUpgradeMutationResult(false, "release_changed", operation.ToRecord());
+            if (current.DownloadCancellationId is not null ||
+                activeCandidate.DownloadCancellationId is not null)
+                return new ReleaseUpgradeMutationResult(false, "download_cancelling", operation.ToRecord());
+            if (!current.IsDownloadFinished ||
+                !activeCandidate.IsDownloadFinished ||
+                current.MediaLibraryMissingSince is not null ||
+                activeCandidate.MediaLibraryMissingSince is not null)
+                return new ReleaseUpgradeMutationResult(false, "release_unavailable", operation.ToRecord());
+            var previous = operation.MappingSnapshots
+                .Where(snapshot => snapshot.Kind == ReleaseUpgradeMappingKind.Previous)
+                .ToList();
+            var candidate = operation.MappingSnapshots
+                .Where(snapshot => snapshot.Kind == ReleaseUpgradeMappingKind.Candidate)
+                .ToList();
+            if (previous.Count == 0 || candidate.Count == 0)
+                return new ReleaseUpgradeMutationResult(false, "snapshot_missing", operation.ToRecord());
+
+            var replacement = BuildCandidateReplacement(
+                previous.Select(FromSnapshot).ToList(),
+                candidate.Select(FromSnapshot).ToList(),
+                operation.CandidateReleaseId);
+            var currentCandidateMappings = await writeContext.FileMappings
+                .AsNoTracking()
+                .Where(mapping => mapping.AnimationInfoId == operation.CandidateReleaseId)
+                .ToListAsync(cancellationToken);
+            if (!MappingSetsMatch(currentCandidateMappings, replacement.Mappings))
+                return new ReleaseUpgradeMutationResult(false, "mapping_changed", operation.ToRecord());
+            var desiredPreviousMappings = previous.Select(snapshot => new Models.FileMapping
+            {
+                Id = snapshot.OriginalMappingId,
+                AnimationInfoId = snapshot.AnimationInfoId,
+                VirtualPath = snapshot.VirtualPath,
+                PhysicalPath = snapshot.PhysicalPath,
+                FileStore = snapshot.FileStore
+            }).ToList();
+            var namespaceConflicts = await VirtualPathNamespaceGuard.FindConflictsAsync(
+                writeContext,
+                operation.CandidateReleaseId,
+                desiredPreviousMappings.Select(mapping => mapping.VirtualPath).ToArray(),
+                cancellationToken);
+            if (namespaceConflicts.Count > 0)
+                return new ReleaseUpgradeMutationResult(false, "mapping_conflict", operation.ToRecord());
+
+            await TransferPlaybackProgressAsync(
+                writeContext,
+                BuildRollbackPlaybackTransfers(
+                    operation.CurrentReleaseId,
+                    operation.CandidateReleaseId,
+                    replacement),
+                cancellationToken);
+            var reconciliation = await FileMappingSetReconciler.ReconcileAcrossOwnersAsync(
+                writeContext,
+                [operation.CurrentReleaseId, operation.CandidateReleaseId],
+                desiredPreviousMappings,
+                cancellationToken);
+            await writeContext.StagedFileMappings
+                .Where(mapping => mapping.AnimationInfoId == operation.CandidateReleaseId)
+                .ExecuteDeleteAsync(cancellationToken);
+            await writeContext.StagedFileMappings.AddRangeAsync(
+                candidate.Select(snapshot => new Models.StagedFileMapping
+                {
+                    Id = snapshot.OriginalMappingId,
+                    AnimationInfoId = snapshot.AnimationInfoId,
+                    VirtualPath = snapshot.VirtualPath,
+                    PhysicalPath = snapshot.PhysicalPath,
+                    FileStore = snapshot.FileStore
+                }),
+                cancellationToken);
+            await writeContext.AnimationInfo
+                .Where(info => info.Id == operation.CandidateReleaseId)
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(info => info.StateVersion, info => info.StateVersion + 1)
+                        .SetProperty(info => info.IsActiveRelease, false)
+                        .SetProperty(info => info.IsRetiredRelease, true),
+                    cancellationToken);
+            await writeContext.AnimationInfo
+                .Where(info => info.Id == operation.CurrentReleaseId)
+                .ExecuteUpdateAsync(setters => setters
+                        .SetProperty(info => info.StateVersion, info => info.StateVersion + 1)
+                        .SetProperty(info => info.IsActiveRelease, true)
+                        .SetProperty(info => info.IsRetiredRelease, false),
+                    cancellationToken);
+            operation.Status = ReleaseUpgradeStatus.RolledBack;
+            operation.CompletedAt = rolledBackAt;
+            await writeContext.SaveChangesAsync(cancellationToken);
+            await reconciliation.RestoreEntryIdentitiesAsync(writeContext, cancellationToken);
+            await RestoreEntryIdentitiesAsync(
+                writeContext,
+                operation.Id,
+                cancellationToken);
+            await transaction.CommitAsync(cancellationToken);
+            return new ReleaseUpgradeMutationResult(true, "rolled_back", operation.ToRecord());
+        });
+    }
+
+    public async Task<IReadOnlyList<ReleaseUpgradeOperation>> GetHistoryAsync(
+        int take,
+        CancellationToken cancellationToken)
+    {
+        if (take is < 1 or > 200) throw new ArgumentOutOfRangeException(nameof(take));
+        return (await context.ReleaseUpgradeOperations.AsNoTracking()
+                .OrderByDescending(operation => operation.CreatedAt)
+                .Take(take)
+                .ToListAsync(cancellationToken))
+            .Select(operation => operation.ToRecord())
+            .ToList();
+    }
+
+    public Task<int> CompleteExpiredAsync(
+        DateTimeOffset completedAt,
+        CancellationToken cancellationToken) =>
+        context.ReleaseUpgradeOperations
+            .Where(operation => operation.Status == ReleaseUpgradeStatus.Applied &&
+                                operation.RollbackUntil <= completedAt)
+            .ExecuteUpdateAsync(setters => setters
+                    .SetProperty(operation => operation.Status, ReleaseUpgradeStatus.Completed)
+                    .SetProperty(operation => operation.CompletedAt, completedAt),
+                cancellationToken);
+
+    private static Models.ReleaseUpgradeMappingSnapshot ToSnapshot(
+        Guid operationId,
+        Models.FileMapping mapping,
+        ReleaseUpgradeMappingKind kind) => new()
+        {
+            Id = Guid.NewGuid(),
+            OperationId = operationId,
+            Kind = kind,
+            OriginalMappingId = mapping.Id,
+            AnimationInfoId = mapping.AnimationInfoId,
+            VirtualPath = mapping.VirtualPath,
+            PhysicalPath = mapping.PhysicalPath,
+            FileStore = mapping.FileStore
+        };
+
+    private static FileMapping ToRecord(Models.StagedFileMapping mapping) => new(
+        mapping.Id,
+        mapping.AnimationInfoId,
+        mapping.VirtualPath,
+        mapping.PhysicalPath,
+        mapping.FileStore);
+
+    private static Models.FileMapping ToFileMapping(Models.StagedFileMapping mapping) => new()
+    {
+        Id = mapping.Id,
+        AnimationInfoId = mapping.AnimationInfoId,
+        VirtualPath = mapping.VirtualPath,
+        PhysicalPath = mapping.PhysicalPath,
+        FileStore = mapping.FileStore
+    };
+
+    private static Task SnapshotEntryIdentitiesAsync(
+        Models.ApplicationContext writeContext,
+        Guid operationId,
+        Guid currentReleaseId,
+        CancellationToken cancellationToken) =>
+        writeContext.Database.ExecuteSqlInterpolatedAsync(
+            $"""
+             INSERT INTO "ReleaseUpgradeEntryIdentitySnapshots"
+                 ("OperationId", "Path", "EntryId", "IsDirectory")
+             SELECT {operationId}, entry."Path", entry."EntryId", entry."IsDirectory"
+             FROM "FileSystemEntries" AS entry
+             WHERE EXISTS (
+                 SELECT 1
+                 FROM "FileMappings" AS mapping
+                 WHERE mapping."AnimationInfoId" = {currentReleaseId}
+                   AND (entry."Path" = mapping."VirtualPath"
+                        OR left(mapping."VirtualPath", length(entry."Path") + 1) = entry."Path" || '/'))
+             ON CONFLICT ("OperationId", "Path") DO UPDATE
+             SET "EntryId" = EXCLUDED."EntryId",
+                 "IsDirectory" = EXCLUDED."IsDirectory"
+             """,
+            cancellationToken);
+
+    private static Task RestoreEntryIdentitiesAsync(
+        Models.ApplicationContext writeContext,
+        Guid operationId,
+        CancellationToken cancellationToken) =>
+        writeContext.Database.ExecuteSqlInterpolatedAsync(
+            $"""
+             UPDATE "FileSystemEntries" AS entry
+             SET "EntryId" = snapshot."EntryId"
+             FROM "ReleaseUpgradeEntryIdentitySnapshots" AS snapshot
+             WHERE snapshot."OperationId" = {operationId}
+               AND snapshot."Path" = entry."Path"
+               AND snapshot."IsDirectory" = entry."IsDirectory"
+               AND snapshot."EntryId" <> entry."EntryId"
+             """,
+            cancellationToken);
+
+    internal static CandidateReplacementPlan BuildCandidateReplacement(
+        IReadOnlyList<Models.FileMapping> previous,
+        IReadOnlyList<Models.FileMapping> candidate,
+        Guid candidateReleaseId)
+    {
+        var previousByRole = previous
+            .GroupBy(mapping => GetStableFileRole(mapping.VirtualPath), StringComparer.OrdinalIgnoreCase)
+            .Where(group => group.Count() == 1)
+            .ToDictionary(group => group.Key, group => group.Single(), StringComparer.OrdinalIgnoreCase);
+        var matchedPreviousIds = new HashSet<Guid>();
+        var used = new HashSet<string>(StringComparer.Ordinal);
+        var result = new List<Models.FileMapping>(candidate.Count);
+        var candidatePathReplacements = new Dictionary<string, string>(StringComparer.Ordinal);
+        var previousPathReplacements = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var mapping in candidate
+                     .OrderBy(item => item.VirtualPath, StringComparer.Ordinal)
+                     .ThenBy(item => item.PhysicalPath, StringComparer.Ordinal)
+                     .ThenBy(item => item.Id))
+        {
+            var role = GetStableFileRole(mapping.VirtualPath);
+            var matchedPrevious = previousByRole.GetValueOrDefault(role);
+            var usesPreviousPath = matchedPrevious is not null &&
+                                   matchedPreviousIds.Add(matchedPrevious.Id);
+            var virtualPath = usesPreviousPath
+                ? matchedPrevious!.VirtualPath
+                : mapping.VirtualPath;
+            if (!used.Add(virtualPath))
+                throw new InvalidOperationException(
+                    $"Candidate replacement produced duplicate virtual path '{virtualPath}'.");
+
+            candidatePathReplacements.Add(mapping.VirtualPath, virtualPath);
+            if (usesPreviousPath)
+                previousPathReplacements.TryAdd(matchedPrevious!.VirtualPath, virtualPath);
+            result.Add(new Models.FileMapping
+            {
+                Id = Guid.NewGuid(),
+                AnimationInfoId = candidateReleaseId,
+                VirtualPath = virtualPath,
+                PhysicalPath = mapping.PhysicalPath,
+                FileStore = mapping.FileStore
+            });
+        }
+
+        return new CandidateReplacementPlan(
+            result,
+            candidatePathReplacements,
+            previousPathReplacements);
+    }
+
+    private static string GetStableFileRole(string virtualPath)
+    {
+        var fileName = virtualPath[(virtualPath.LastIndexOf('/') + 1)..];
+        var extension = Path.GetExtension(fileName);
+        var stem = extension.Length == 0 ? fileName : fileName[..^extension.Length];
+        var roleExtension = MediaFileTypes.VideoExtensions.Contains(extension)
+            ? "<video>"
+            : extension;
+        return CollisionSuffixRegex().Replace(stem, string.Empty) + roleExtension;
+    }
+
+    private static Models.FileMapping FromSnapshot(Models.ReleaseUpgradeMappingSnapshot snapshot) => new()
+    {
+        Id = snapshot.OriginalMappingId,
+        AnimationInfoId = snapshot.AnimationInfoId,
+        VirtualPath = snapshot.VirtualPath,
+        PhysicalPath = snapshot.PhysicalPath,
+        FileStore = snapshot.FileStore
+    };
+
+    private static bool AreSameEpisode(
+        Models.ApplicationContext writeContext,
+        Models.AnimationInfo current,
+        Models.AnimationInfo candidate)
+    {
+        var currentAnimationId = writeContext.Entry(current)
+            .Property<Guid?>("AnimationId")
+            .CurrentValue;
+        var candidateAnimationId = writeContext.Entry(candidate)
+            .Property<Guid?>("AnimationId")
+            .CurrentValue;
+        return currentAnimationId is not null &&
+               currentAnimationId == candidateAnimationId &&
+               current.Season is not null &&
+               current.Season == candidate.Season &&
+               current.Episode is not null &&
+               current.Episode == candidate.Episode;
+    }
+
+    private static bool MappingSetsMatch(
+        IReadOnlyCollection<Models.FileMapping> actual,
+        IReadOnlyCollection<Models.FileMapping> expected)
+    {
+        if (actual.Count != expected.Count) return false;
+        var expectedMappings = expected
+            .Select(mapping => (mapping.VirtualPath, mapping.PhysicalPath, mapping.FileStore))
+            .ToHashSet();
+        return actual.All(mapping => expectedMappings.Contains(
+            (mapping.VirtualPath, mapping.PhysicalPath, mapping.FileStore)));
+    }
+
+    private static bool MappingSetsMatch(
+        IReadOnlyCollection<Models.FileMapping> actual,
+        IReadOnlyCollection<FileMapping> expected)
+    {
+        if (actual.Count != expected.Count) return false;
+        var expectedMappings = expected
+            .Select(mapping => (mapping.VirtualPath, mapping.PhysicalPath, mapping.FileStore))
+            .ToHashSet();
+        return actual.All(mapping => expectedMappings.Contains(
+            (mapping.VirtualPath, mapping.PhysicalPath, mapping.FileStore)));
+    }
+
+    internal static IReadOnlyDictionary<PlaybackLocation, PlaybackLocation>
+        BuildActivationPlaybackTransfers(
+            Guid currentReleaseId,
+            Guid candidateReleaseId,
+            CandidateReplacementPlan replacement)
+    {
+        var transfers = replacement.CandidatePathReplacements.ToDictionary(
+            pair => new PlaybackLocation(candidateReleaseId, pair.Key),
+            pair => new PlaybackLocation(candidateReleaseId, pair.Value));
+        foreach (var pair in replacement.PreviousPathReplacements)
+        {
+            transfers[new PlaybackLocation(currentReleaseId, pair.Key)] =
+                new PlaybackLocation(candidateReleaseId, pair.Value);
+        }
+
+        return transfers;
+    }
+
+    private static IReadOnlyDictionary<PlaybackLocation, PlaybackLocation>
+        BuildRollbackPlaybackTransfers(
+            Guid currentReleaseId,
+            Guid candidateReleaseId,
+            CandidateReplacementPlan replacement)
+    {
+        var transfers = new Dictionary<PlaybackLocation, PlaybackLocation>();
+        foreach (var pair in replacement.PreviousPathReplacements)
+        {
+            transfers[new PlaybackLocation(candidateReleaseId, pair.Value)] =
+                new PlaybackLocation(currentReleaseId, pair.Key);
+        }
+
+        return transfers;
+    }
+
+    internal static async Task TransferPlaybackProgressAsync(
+        Models.ApplicationContext writeContext,
+        IReadOnlyDictionary<PlaybackLocation, PlaybackLocation> transfers,
+        CancellationToken cancellationToken)
+    {
+        if (transfers.Count == 0) return;
+
+        var ownerIds = transfers.Keys
+            .Select(location => location.AnimationInfoId)
+            .Concat(transfers.Values.Select(location => location.AnimationInfoId))
+            .Distinct()
+            .ToArray();
+        var rows = await writeContext.PlaybackProgresses
+            .AsNoTracking()
+            .Where(progress => ownerIds.Contains(progress.AnimationInfoId))
+            .ToListAsync(cancellationToken);
+        var targets = transfers.Values.ToHashSet();
+        var affected = rows
+            .Where(progress =>
+            {
+                var location = new PlaybackLocation(
+                    progress.AnimationInfoId,
+                    progress.VirtualPath);
+                return transfers.ContainsKey(location) || targets.Contains(location);
+            })
+            .ToList();
+        if (affected.Count == 0) return;
+
+        var affectedIds = affected.Select(progress => progress.Id).ToArray();
+        await writeContext.PlaybackProgresses
+            .Where(progress => affectedIds.Contains(progress.Id))
+            .ExecuteDeleteAsync(cancellationToken);
+
+        var merged = affected
+            .Select(progress =>
+            {
+                var source = new PlaybackLocation(
+                    progress.AnimationInfoId,
+                    progress.VirtualPath);
+                var target = transfers.GetValueOrDefault(source, source);
+                return (Progress: progress, Target: target);
+            })
+            .GroupBy(item => new
+            {
+                item.Progress.UserId,
+                item.Target.AnimationInfoId,
+                item.Target.VirtualPath
+            })
+            .Select(group =>
+            {
+                // If both releases have progress for the same user/file role,
+                // retain the last user action rather than reviving stale state.
+                var winner = group
+                    .OrderByDescending(item => item.Progress.UpdatedAt)
+                    .ThenByDescending(item => item.Progress.Id)
+                    .First()
+                    .Progress;
+                return new Models.PlaybackProgress
+                {
+                    Id = winner.Id,
+                    UserId = group.Key.UserId,
+                    AnimationInfoId = group.Key.AnimationInfoId,
+                    VirtualPath = group.Key.VirtualPath,
+                    PositionSeconds = winner.PositionSeconds,
+                    DurationSeconds = winner.DurationSeconds,
+                    IsWatched = winner.IsWatched,
+                    UpdatedAt = winner.UpdatedAt,
+                    WatchedAt = winner.WatchedAt
+                };
+            })
+            .ToList();
+        await writeContext.PlaybackProgresses.AddRangeAsync(merged, cancellationToken);
+    }
+
+    [GeneratedRegex(@" \(\d+\)$", RegexOptions.CultureInvariant)]
+    private static partial Regex CollisionSuffixRegex();
+
+    internal readonly record struct PlaybackLocation(Guid AnimationInfoId, string VirtualPath);
+
+    internal sealed record CandidateReplacementPlan(
+        IReadOnlyList<Models.FileMapping> Mappings,
+        IReadOnlyDictionary<string, string> CandidatePathReplacements,
+        IReadOnlyDictionary<string, string> PreviousPathReplacements);
+
+    private static IReadOnlyList<string> ParseReasons(string? json)
+    {
+        if (string.IsNullOrWhiteSpace(json)) return [];
+        try
+        {
+            return System.Text.Json.JsonSerializer.Deserialize<string[]>(json) ?? [];
+        }
+        catch (System.Text.Json.JsonException)
+        {
+            return [];
+        }
+    }
+}
+
+internal static class ReleaseUpgradeRepositoryConverters
+{
+    public static ReleaseUpgradeOperation ToRecord(this Models.ReleaseUpgradeOperation operation) =>
+        new(operation.Id,
+            operation.CurrentReleaseId,
+            operation.CandidateReleaseId,
+            operation.Status,
+            operation.CurrentScore,
+            operation.CandidateScore,
+            operation.CreatedAt,
+            operation.VerifiedAt,
+            operation.AppliedAt,
+            operation.RollbackUntil,
+            operation.CompletedAt,
+            operation.FailureSummary,
+            operation.DownloadPreparedAt,
+            operation.DownloadSubmittedAt,
+            operation.DownloadSubmissionLeaseId,
+            operation.DownloadSubmissionLeaseUntil,
+            operation.DownloadCancellationRemoveFile);
+}
diff --git a/SecondDimensionWatcherReDive/Repositories/RepositoryConverter.cs b/SecondDimensionWatcherReDive/Repositories/RepositoryConverter.cs
index 260e342..4b264d0 100644
--- a/SecondDimensionWatcherReDive/Repositories/RepositoryConverter.cs
+++ b/SecondDimensionWatcherReDive/Repositories/RepositoryConverter.cs
@@ -47,7 +47,20 @@ public static DataRepo.AnimationInfo ToRecord(this Models.AnimationInfo entity)
             entity.DownloadAttemptId,
             entity.DownloadCancellationId,
             entity.MediaLibrarySourceId,
-            entity.MediaLibraryMissingSince);
+            entity.MediaLibraryMissingSince,
+            entity.ReleaseIdentity,
+            entity.FeedItemGuid,
+            entity.EnclosureId,
+            entity.TorrentInfoHash,
+            entity.ReleaseSubtitleGroup,
+            entity.ReleaseResolution,
+            entity.ReleaseCodec,
+            entity.ReleaseLanguages,
+            entity.ReleaseScore,
+            entity.ReleaseScoreReasonsJson,
+            entity.ExpectedEpisodeCount,
+            entity.IngestedAt,
+            entity.IsActiveRelease);
 
     public static DataRepo.Animation ToRecord(this Models.Animation entity) =>
         new(entity.Id,
@@ -103,7 +116,10 @@ public static DataRepo.SubscriptionAutomationPolicy ToRecord(
             entity.ExcludedKeywords,
             entity.Mode,
             entity.CreatedAt,
-            entity.UpdatedAt);
+            entity.UpdatedAt,
+            entity.EnableVersionUpgrade,
+            entity.MinimumUpgradeScore,
+            entity.UpgradeRollbackHours);
 
     public static DataRepo.WebDavToken ToRecord(this Models.WebDavToken entity) =>
         new(entity.Id,
@@ -168,7 +184,20 @@ public static Models.AnimationInfo ToEntity(this DataRepo.AnimationInfo record)
             DownloadAttemptId = record.DownloadAttemptId,
             DownloadCancellationId = record.DownloadCancellationId,
             MediaLibrarySourceId = record.MediaLibrarySourceId,
-            MediaLibraryMissingSince = record.MediaLibraryMissingSince
+            MediaLibraryMissingSince = record.MediaLibraryMissingSince,
+            ReleaseIdentity = record.ReleaseIdentity,
+            FeedItemGuid = record.FeedItemGuid,
+            EnclosureId = record.EnclosureId,
+            TorrentInfoHash = record.TorrentInfoHash,
+            ReleaseSubtitleGroup = record.ReleaseSubtitleGroup,
+            ReleaseResolution = record.ReleaseResolution,
+            ReleaseCodec = record.ReleaseCodec,
+            ReleaseLanguages = record.ReleaseLanguages?.ToArray() ?? [],
+            ReleaseScore = record.ReleaseScore,
+            ReleaseScoreReasonsJson = record.ReleaseScoreReasonsJson,
+            ExpectedEpisodeCount = record.ExpectedEpisodeCount,
+            IngestedAt = record.IngestedAt ?? DateTimeOffset.UtcNow,
+            IsActiveRelease = record.IsActiveRelease
         };
 
     public static Models.Animation ToEntity(this DataRepo.Animation record) =>
@@ -252,7 +281,10 @@ public static Models.SubscriptionAutomationPolicy ToEntity(
             ExcludedKeywords = record.ExcludedKeywords.ToArray(),
             Mode = record.Mode,
             CreatedAt = record.CreatedAt,
-            UpdatedAt = record.UpdatedAt
+            UpdatedAt = record.UpdatedAt,
+            EnableVersionUpgrade = record.EnableVersionUpgrade,
+            MinimumUpgradeScore = record.MinimumUpgradeScore,
+            UpgradeRollbackHours = record.UpgradeRollbackHours
         };
 
     public static Models.WebDavToken ToEntity(this DataRepo.WebDavToken record) =>
@@ -326,6 +358,17 @@ public static void ApplyTo(this DataRepo.AnimationInfo record, Models.AnimationI
         entity.DownloadCancellationId = record.DownloadCancellationId;
         entity.MediaLibrarySourceId = record.MediaLibrarySourceId;
         entity.MediaLibraryMissingSince = record.MediaLibraryMissingSince;
+        entity.ReleaseIdentity = record.ReleaseIdentity;
+        entity.FeedItemGuid = record.FeedItemGuid;
+        entity.EnclosureId = record.EnclosureId;
+        entity.TorrentInfoHash = record.TorrentInfoHash;
+        entity.ReleaseSubtitleGroup = record.ReleaseSubtitleGroup;
+        entity.ReleaseResolution = record.ReleaseResolution;
+        entity.ReleaseCodec = record.ReleaseCodec;
+        entity.ReleaseLanguages = record.ReleaseLanguages?.ToArray() ?? [];
+        entity.ReleaseScore = record.ReleaseScore;
+        entity.ReleaseScoreReasonsJson = record.ReleaseScoreReasonsJson;
+        entity.ExpectedEpisodeCount = record.ExpectedEpisodeCount;
     }
 
     public static void ApplyTo(this DataRepo.SeasonBangumi record, Models.SeasonBangumi entity)
@@ -359,5 +402,8 @@ public static void ApplyTo(
         entity.Mode = record.Mode;
         entity.CreatedAt = record.CreatedAt;
         entity.UpdatedAt = record.UpdatedAt;
+        entity.EnableVersionUpgrade = record.EnableVersionUpgrade;
+        entity.MinimumUpgradeScore = record.MinimumUpgradeScore;
+        entity.UpgradeRollbackHours = record.UpgradeRollbackHours;
     }
 }
diff --git a/SecondDimensionWatcherReDive/Repositories/VirtualPathNamespaceGuard.cs b/SecondDimensionWatcherReDive/Repositories/VirtualPathNamespaceGuard.cs
index 6a2e0f2..0123381 100644
--- a/SecondDimensionWatcherReDive/Repositories/VirtualPathNamespaceGuard.cs
+++ b/SecondDimensionWatcherReDive/Repositories/VirtualPathNamespaceGuard.cs
@@ -21,8 +21,22 @@ public static async Task<IReadOnlyList<VirtualPathNamespaceConflict>> FindConfli
         Models.ApplicationContext context,
         Guid animationInfoId,
         IReadOnlyCollection<string> proposedPaths,
+        CancellationToken cancellationToken) =>
+        await FindConflictsAsync(
+            context,
+            [animationInfoId],
+            proposedPaths,
+            cancellationToken);
+
+    public static async Task<IReadOnlyList<VirtualPathNamespaceConflict>> FindConflictsAsync(
+        Models.ApplicationContext context,
+        IReadOnlyCollection<Guid> animationInfoIds,
+        IReadOnlyCollection<string> proposedPaths,
         CancellationToken cancellationToken)
     {
+        if (animationInfoIds.Count == 0)
+            throw new ArgumentException("At least one mapping owner is required.", nameof(animationInfoIds));
+        var ownerIds = animationInfoIds.ToHashSet();
         var requested = proposedPaths
             .Order(StringComparer.Ordinal)
             .ToArray();
@@ -82,7 +96,7 @@ public static async Task<IReadOnlyList<VirtualPathNamespaceConflict>> FindConfli
             .ToDictionaryAsync(entry => entry.Path, StringComparer.Ordinal, cancellationToken);
         var ownedPaths = await context.FileMappings
             .AsNoTracking()
-            .Where(mapping => mapping.AnimationInfoId == animationInfoId)
+            .Where(mapping => ownerIds.Contains(mapping.AnimationInfoId))
             .Select(mapping => mapping.VirtualPath)
             .ToListAsync(cancellationToken);
 
@@ -92,7 +106,8 @@ public static async Task<IReadOnlyList<VirtualPathNamespaceConflict>> FindConfli
             {
                 if (nodes.TryGetValue(ancestor, out var ancestorNode)
                     && !ancestorNode.IsDirectory
-                    && ancestorNode.AnimationInfoId != animationInfoId)
+                    && (!ancestorNode.AnimationInfoId.HasValue ||
+                        !ownerIds.Contains(ancestorNode.AnimationInfoId.Value)))
                 {
                     conflicts.Add(new VirtualPathNamespaceConflict(
                         path,
@@ -105,7 +120,8 @@ public static async Task<IReadOnlyList<VirtualPathNamespaceConflict>> FindConfli
             if (!nodes.TryGetValue(path, out var exactNode)) continue;
             if (!exactNode.IsDirectory)
             {
-                if (exactNode.AnimationInfoId != animationInfoId)
+                if (!exactNode.AnimationInfoId.HasValue ||
+                    !ownerIds.Contains(exactNode.AnimationInfoId.Value))
                 {
                     conflicts.Add(new VirtualPathNamespaceConflict(
                         path,
diff --git a/SecondDimensionWatcherReDive/Services/CompleteDownloadBackgroundService.cs b/SecondDimensionWatcherReDive/Services/CompleteDownloadBackgroundService.cs
index 49ca2ac..8996ab4 100644
--- a/SecondDimensionWatcherReDive/Services/CompleteDownloadBackgroundService.cs
+++ b/SecondDimensionWatcherReDive/Services/CompleteDownloadBackgroundService.cs
@@ -6,6 +6,7 @@
 using SecondDimensionWatcherReDive.Plugin;
 using SecondDimensionWatcherReDive.Utils.FileStore;
 using SecondDimensionWatcherReDive.Utils.Incidents;
+using SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
 
 namespace SecondDimensionWatcherReDive.Services;
 
@@ -74,6 +75,9 @@ internal async Task ProcessRequestAsync(
 
         if (info is null)
         {
+            if (scope.ServiceProvider.GetService<IReleaseUpgradeCoordinator>() is { } retryCoordinator &&
+                await retryCoordinator.TryActivateCandidateAsync(request.ItemId, cancellationToken) is not null)
+                return;
             LogCompletionIgnored(logger, request.ItemId);
             return;
         }
@@ -98,11 +102,13 @@ await incidentReporter.ResolveAsync(
         }
 
         // Build virtual-fs mappings for the downloaded files.
+        var mappingSucceeded = false;
         try
         {
             var fileMapper = scope.ServiceProvider.GetRequiredService<IFileMapper>();
             if (!await fileMapper.MapDownloadAsync(request.ItemId, cancellationToken))
                 throw new InvalidOperationException("No file mapping could be produced.");
+            mappingSucceeded = true;
 
             if (incidentReporter is not null)
             {
@@ -127,6 +133,11 @@ await incidentReporter.ReportAsync(new IncidentReport(
             }
         }
 
+        if (mappingSucceeded && scope.ServiceProvider.GetService<IReleaseUpgradeCoordinator>() is { } coordinator)
+        {
+            await coordinator.TryActivateCandidateAsync(request.ItemId, cancellationToken);
+        }
+
         // Fire plugin event
         try
         {
diff --git a/SecondDimensionWatcherReDive/Services/InferAnimationMetadata.cs b/SecondDimensionWatcherReDive/Services/InferAnimationMetadata.cs
index 2018e10..d23153b 100644
--- a/SecondDimensionWatcherReDive/Services/InferAnimationMetadata.cs
+++ b/SecondDimensionWatcherReDive/Services/InferAnimationMetadata.cs
@@ -91,6 +91,16 @@ private async Task ProcessItem(
                 if (details != null && !string.IsNullOrEmpty(details.Overview))
                     item = item with { Description = details.Overview };
 
+                if (result.Season is { } inferredSeason)
+                {
+                    var expectedEpisodeCount = await tmdbTool.GetExpectedEpisodeCountAsync(
+                        tmdbIdInt,
+                        inferredSeason,
+                        cancellationToken);
+                    if (expectedEpisodeCount is not null)
+                        item = item with { ExpectedEpisodeCount = expectedEpisodeCount };
+                }
+
                 var animation = await animationRepository
                     .FindByTmdbIdAsync(result.TmdbId, cancellationToken);
 
diff --git a/SecondDimensionWatcherReDive/Services/MediaLibraryScanner.cs b/SecondDimensionWatcherReDive/Services/MediaLibraryScanner.cs
index 8b17ee8..2e7d095 100644
--- a/SecondDimensionWatcherReDive/Services/MediaLibraryScanner.cs
+++ b/SecondDimensionWatcherReDive/Services/MediaLibraryScanner.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Options;
 using SecondDimensionWatcherReDive.Framework.DataRepository;
 using SecondDimensionWatcherReDive.Framework.FileDownload;
+using SecondDimensionWatcherReDive.Framework.Feed;
 using SecondDimensionWatcherReDive.Framework.FileStore;
 using SecondDimensionWatcherReDive.Utils.FileStore;
 
@@ -399,7 +400,11 @@ private static AnimationInfo CreateAnimationInfo(
             AiRetryCount: 0,
             ReleaseSizeBytes: candidate.TotalSize,
             MetadataStatus: MetadataReviewStatus.Pending,
-            MediaLibrarySourceId: source.Id);
+            MediaLibrarySourceId: source.Id,
+            ReleaseIdentity: ReleaseIdentity.CreateMediaImport(
+                source.Id,
+                FileStores.LocalDiskStore,
+                candidate.FullPath));
     }
 
     private static string BuildDownloadUrl(Guid sourceId, string relativePath) =>
diff --git a/SecondDimensionWatcherReDive/Services/ReleaseUpgradeBackgroundService.cs b/SecondDimensionWatcherReDive/Services/ReleaseUpgradeBackgroundService.cs
new file mode 100644
index 0000000..fc6fca1
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Services/ReleaseUpgradeBackgroundService.cs
@@ -0,0 +1,136 @@
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
+
+namespace SecondDimensionWatcherReDive.Services;
+
+public sealed class ReleaseUpgradeBackgroundService(
+    IServiceScopeFactory scopeFactory,
+    ILogger<ReleaseUpgradeBackgroundService> logger) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
+        do
+        {
+            try
+            {
+                await ProcessAsync(stoppingToken);
+            }
+            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Automatic release-upgrade pass failed");
+            }
+        } while (await timer.WaitForNextTickAsync(stoppingToken));
+    }
+
+    internal async Task ProcessAsync(CancellationToken cancellationToken)
+    {
+        await using var scope = scopeFactory.CreateAsyncScope();
+        var repository = scope.ServiceProvider.GetRequiredService<IReleaseUpgradeRepository>();
+        await repository.CompleteExpiredAsync(DateTimeOffset.UtcNow, cancellationToken);
+        await repository.ClearExpiredDownloadSubmissionLeasesWithoutCancellationAsync(
+            cancellationToken);
+        var coordinator = scope.ServiceProvider.GetRequiredService<IReleaseUpgradeCoordinator>();
+        var animationInfoRepository = scope.ServiceProvider
+            .GetRequiredService<IAnimationInfoRepository>();
+        var pendingDownloadSubmissions =
+            await animationInfoRepository.GetPendingDownloadSubmissionsAsync(
+                take: 20,
+                cancellationToken);
+        foreach (var pendingSubmission in pendingDownloadSubmissions)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                await coordinator.ReconcilePendingDownloadSubmissionAsync(
+                    pendingSubmission,
+                    cancellationToken);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(
+                    exception,
+                    "Download submission recovery failed for animation {AnimationInfoId}",
+                    pendingSubmission.AnimationInfoId);
+            }
+        }
+
+        var pendingCancellations = await repository.GetPendingDownloadCancellationsAsync(
+            take: 20,
+            cancellationToken);
+        foreach (var pendingCancellation in pendingCancellations)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                await coordinator.ReconcilePendingDownloadCancellationAsync(
+                    pendingCancellation,
+                    cancellationToken);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(
+                    exception,
+                    "Release-upgrade cancellation reconciliation failed for operation {OperationId}",
+                    pendingCancellation.OperationId);
+            }
+        }
+
+        var pendingDownloadCancellations =
+            await animationInfoRepository.GetPendingDownloadCancellationsAsync(
+                take: 20,
+                cancellationToken);
+        foreach (var pendingCancellation in pendingDownloadCancellations)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                await coordinator.ReconcilePendingDownloadCancellationAsync(
+                    pendingCancellation,
+                    cancellationToken);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(
+                    exception,
+                    "Download cancellation reconciliation failed for animation {AnimationInfoId}",
+                    pendingCancellation.AnimationInfoId);
+            }
+        }
+
+        var readyCandidates = await repository.GetReadyCandidateIdsAsync(
+            take: 20,
+            cancellationToken);
+        foreach (var candidateId in readyCandidates)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            await coordinator.TryActivateCandidateAsync(candidateId, cancellationToken);
+        }
+
+        var candidates = await repository.GetCandidatesAsync(
+            automaticOnly: true,
+            take: 20,
+            cancellationToken);
+        foreach (var candidate in candidates)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            await coordinator.ExecuteAsync(candidate, dryRun: false, cancellationToken);
+        }
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Services/SyncFeed.cs b/SecondDimensionWatcherReDive/Services/SyncFeed.cs
index 01c51af..312f2f1 100644
--- a/SecondDimensionWatcherReDive/Services/SyncFeed.cs
+++ b/SecondDimensionWatcherReDive/Services/SyncFeed.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Security.Cryptography;
 using System.Text.Json;
 using BencodeNET.Objects;
@@ -24,10 +25,15 @@ internal partial class SyncFeed(
     IServiceScopeFactory scopeFactory,
     ISubscriptionAutomationMatcher automationMatcher,
     IIncidentReporter? incidentReporter = null,
+    ISubscriptionReleaseMetadataExtractor? metadataExtractor = null,
+    IReleaseScoringService? releaseScoringService = null,
     INotificationPublisher? notificationPublisher = null)
     : ScheduledTaskBase
 {
     private static readonly JsonSerializerOptions ExplanationJsonOptions = new(JsonSerializerDefaults.Web);
+    private static readonly TimeSpan DownloadSubmissionLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadSubmissionRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadCancellationLeaseDuration = TimeSpan.FromMinutes(3);
 
     public override string Id => "SyncFeed";
     public override TimeSpan Interval => TimeSpan.FromMinutes(10);
@@ -119,41 +125,72 @@ private async Task ProcessSingle(AnimationAddRequest request, CancellationToken
         await using var scope = scopeFactory.CreateAsyncScope();
         var animationInfoRepository = scope.ServiceProvider.GetRequiredService<IAnimationInfoRepository>();
 
-        //Only process non-exist items
-        if (await animationInfoRepository.FindByTitleAsync(request.Title, cancellationToken) == null)
+        // Feed scans can contain hundreds of already-known entries. Avoid
+        // downloading every historical .torrent again merely to rediscover its
+        // infohash; the database identity still arbitrates concurrent first-seen
+        // inserts across processes after the payload has been verified.
+        if (request.DownloadType == FileDownloadTypes.TorrentDownload &&
+            await animationInfoRepository.ExistsReleaseSourceAsync(
+                request.FeedId,
+                request.FeedItemGuid,
+                request.EnclosureId,
+                request.DownloadUrl,
+                cancellationToken))
+            return;
+
+        // For legacy non-torrent feeds without an external item identifier, the
+        // download URL is the release identity. Preserve the inexpensive exact
+        // duplicate short-circuit while allowing same-title releases with a new
+        // GUID, enclosure, infohash, or URL to coexist as upgrade candidates.
+        if (request.DownloadType != FileDownloadTypes.TorrentDownload &&
+            string.IsNullOrWhiteSpace(request.FeedItemGuid) &&
+            string.IsNullOrWhiteSpace(request.EnclosureId))
         {
-            try
+            var existing = await animationInfoRepository.FindByTitleAsync(
+                request.Title,
+                cancellationToken);
+            if (string.Equals(existing?.DownloadUrl, request.DownloadUrl, StringComparison.Ordinal))
+                return;
+        }
+
+        try
+        {
+            SubscriptionAutomationPolicy? policy = null;
+            if (request.FeedId is { } feedId)
             {
-                SubscriptionAutomationPolicy? policy = null;
-                if (request.FeedId is { } feedId)
-                {
-                    var policyRepository = scope.ServiceProvider
-                        .GetRequiredService<ISubscriptionAutomationPolicyRepository>();
-                    policy = await policyRepository.FindByFeedIdAsync(feedId, cancellationToken);
-                }
+                var policyRepository = scope.ServiceProvider
+                    .GetRequiredService<ISubscriptionAutomationPolicyRepository>();
+                policy = await policyRepository.FindByFeedIdAsync(feedId, cancellationToken);
+            }
 
-                var torrentData = request.DownloadType switch
-                {
-                    FileDownloadTypes.TorrentDownload => await DownloadTorrentData(request, cancellationToken),
-                    _ => new TorrentData(Array.Empty<byte>(), request.AdditionalDownloadInfo, request.ContentLength)
-                };
+            var torrentData = request.DownloadType switch
+            {
+                FileDownloadTypes.TorrentDownload => await DownloadTorrentData(request, cancellationToken),
+                _ => new TorrentData(Array.Empty<byte>(), request.AdditionalDownloadInfo, request.ContentLength)
+            };
 
-                if (request.DownloadType == FileDownloadTypes.TorrentDownload &&
-                    request.ContentLength is { } advertisedSize &&
-                    advertisedSize != torrentData.PayloadSizeBytes)
-                    throw new InvalidTorrentDataException(request.DownloadUrl, "advertised and declared payload sizes differ");
+            if (request.DownloadType == FileDownloadTypes.TorrentDownload &&
+                request.ContentLength is { } advertisedSize &&
+                advertisedSize != torrentData.PayloadSizeBytes)
+                throw new InvalidTorrentDataException(request.DownloadUrl, "advertised and declared payload sizes differ");
 
-                SubscriptionAutomationEvaluation? evaluation = null;
-                if (policy is not null)
-                {
-                    evaluation = automationMatcher.Evaluate(
-                        policy,
-                        request with { ContentLength = torrentData.PayloadSizeBytes });
-                    if (!evaluation.Matched)
-                        return;
-                }
+            var releaseWithSize = request with { ContentLength = torrentData.PayloadSizeBytes };
+            SubscriptionAutomationEvaluation? evaluation = null;
+            if (policy is not null)
+            {
+                evaluation = automationMatcher.Evaluate(policy, releaseWithSize);
+                if (!evaluation.Matched)
+                    return;
+            }
+
+            var metadata = evaluation?.Metadata ?? metadataExtractor?.Extract(releaseWithSize) ??
+                new SubscriptionReleaseMetadata(null, null, null, [], torrentData.PayloadSizeBytes);
+            var score = releaseScoringService?.Score(metadata, policy) ?? new ReleaseScore(0, []);
+            var torrentInfoHash = request.DownloadType == FileDownloadTypes.TorrentDownload
+                ? torrentData.Hash
+                : null;
 
-                var info = new AnimationInfo(
+            var info = new AnimationInfo(
                     Guid.NewGuid(),
                     request.Title,
                     request.Description,
@@ -187,78 +224,100 @@ request.ContentLength is { } advertisedSize &&
                     },
                     AutomationExplanationJson: evaluation is null
                         ? null
-                        : JsonSerializer.Serialize(evaluation.Explanations, ExplanationJsonOptions));
+                        : JsonSerializer.Serialize(evaluation.Explanations, ExplanationJsonOptions),
+                    ReleaseIdentity: ReleaseIdentity.Create(
+                        request.FeedId,
+                        request.FeedItemGuid,
+                        request.EnclosureId,
+                        torrentInfoHash,
+                        request.DownloadUrl),
+                    FeedItemGuid: request.FeedItemGuid,
+                    EnclosureId: request.EnclosureId,
+                    TorrentInfoHash: torrentInfoHash,
+                    ReleaseSubtitleGroup: metadata.SubtitleGroup,
+                    ReleaseResolution: metadata.Resolution,
+                    ReleaseCodec: metadata.Codec,
+                    ReleaseLanguages: metadata.Languages,
+                    ReleaseScore: score.Value,
+                    ReleaseScoreReasonsJson: JsonSerializer.Serialize(score.Reasons, ExplanationJsonOptions));
+            try
+            {
                 await animationInfoRepository.AddAsync(info, cancellationToken);
+            }
+            catch (DuplicateReleaseException)
+            {
+                return;
+            }
 
-                if (notificationPublisher is not null)
+            if (notificationPublisher is not null)
+            {
+                if (policy?.Mode == SubscriptionAutomationMode.NotifyOnly)
                 {
-                    if (policy?.Mode == SubscriptionAutomationMode.NotifyOnly)
-                    {
-                        await notificationPublisher.PublishAsync(new NotificationEvent(
-                            NotificationEventType.ReleaseMatched,
-                            $"release-matched:{info.Id}",
-                            "Subscription release matched",
-                            info.Title,
-                            $"/todo?focus=automation:{info.Id}"), cancellationToken);
-                    }
-                    else if (policy?.Mode == SubscriptionAutomationMode.ManualConfirm)
-                    {
-                        await notificationPublisher.PublishAsync(new NotificationEvent(
-                            NotificationEventType.DownloadPendingConfirmation,
-                            $"download-pending-confirmation:{info.Id}",
-                            "Download confirmation required",
-                            info.Title,
-                            $"/todo?focus=automation:{info.Id}"), cancellationToken);
-                    }
+                    await notificationPublisher.PublishAsync(new NotificationEvent(
+                        NotificationEventType.ReleaseMatched,
+                        $"release-matched:{info.Id}",
+                        "Subscription release matched",
+                        info.Title,
+                        $"/todo?focus=automation:{info.Id}"), cancellationToken);
                 }
+                else if (policy?.Mode == SubscriptionAutomationMode.ManualConfirm)
+                {
+                    await notificationPublisher.PublishAsync(new NotificationEvent(
+                        NotificationEventType.DownloadPendingConfirmation,
+                        $"download-pending-confirmation:{info.Id}",
+                        "Download confirmation required",
+                        info.Title,
+                        $"/todo?focus=automation:{info.Id}"), cancellationToken);
+                }
+            }
 
-                if (incidentReporter is not null)
-                    await incidentReporter.ResolveAsync(
-                        IncidentType.FeedFailure,
-                        CreateDownloadIncidentSourceId(request.DownloadUrl),
-                        cancellationToken);
+            if (incidentReporter is not null)
+                await incidentReporter.ResolveAsync(
+                    IncidentType.FeedFailure,
+                    CreateDownloadIncidentSourceId(request.DownloadUrl),
+                    cancellationToken);
 
-                if (policy?.Mode == SubscriptionAutomationMode.AutoDownload)
+            if (policy?.Mode == SubscriptionAutomationMode.AutoDownload)
+            {
+                var started = await QueueAutomaticDownloadAsync(
+                    info,
+                    animationInfoRepository,
+                    scope.ServiceProvider.GetRequiredService<IFileMappingRepository>(),
+                    scope.ServiceProvider.GetRequiredService<IFileDownloadClientProvider>(),
+                    cancellationToken);
+                if (!started && notificationPublisher is not null)
                 {
-                    var started = await QueueAutomaticDownloadAsync(
-                        info,
-                        animationInfoRepository,
-                        scope.ServiceProvider.GetRequiredService<IFileDownloadClientProvider>(),
+                    // A failed compensation can leave the remote attempt durably
+                    // tracked for startup recovery. Only announce terminal failure
+                    // once the database confirms that state.
+                    var failed = await animationInfoRepository.FindByIdAsync(
+                        info.Id,
                         cancellationToken);
-                    if (!started && notificationPublisher is not null)
+                    if (failed?.AutomationDisposition ==
+                        SubscriptionAutomationDisposition.AutoDownloadFailed)
                     {
-                        // A failed compensation can leave the remote attempt
-                        // durably tracked for startup recovery. Only announce a
-                        // terminal failure once the database confirms that state.
-                        var failed = await animationInfoRepository.FindByIdAsync(
-                            info.Id,
-                            cancellationToken);
-                        if (failed?.AutomationDisposition ==
-                            SubscriptionAutomationDisposition.AutoDownloadFailed)
-                        {
-                            await notificationPublisher.PublishAsync(new NotificationEvent(
-                                NotificationEventType.DownloadFailed,
-                                $"auto-download-failed:{info.Id}",
-                                "Automatic download failed",
-                                info.Title,
-                                $"/todo?focus=automation:{info.Id}"), cancellationToken);
-                        }
+                        await notificationPublisher.PublishAsync(new NotificationEvent(
+                            NotificationEventType.DownloadFailed,
+                            $"auto-download-failed:{info.Id}",
+                            "Automatic download failed",
+                            info.Title,
+                            $"/todo?focus=automation:{info.Id}"), cancellationToken);
                     }
                 }
             }
-            catch (InvalidTorrentDataException e)
+        }
+        catch (InvalidTorrentDataException e)
+        {
+            LogSyncFeedWarning(logger, e.Message);
+            if (incidentReporter is not null)
             {
-                LogSyncFeedWarning(logger, e.Message);
-                if (incidentReporter is not null)
-                {
-                    await incidentReporter.ReportAsync(new IncidentReport(
-                            IncidentType.FeedFailure,
-                            IncidentSeverity.Error,
-                            "Feed item contains invalid torrent data",
-                            e.Message,
-                            CreateDownloadIncidentSourceId(request.DownloadUrl)),
-                        cancellationToken);
-                }
+                await incidentReporter.ReportAsync(new IncidentReport(
+                        IncidentType.FeedFailure,
+                        IncidentSeverity.Error,
+                        "Feed item contains invalid torrent data",
+                        e.Message,
+                        CreateDownloadIncidentSourceId(request.DownloadUrl)),
+                    cancellationToken);
             }
         }
     }
@@ -266,42 +325,89 @@ await incidentReporter.ReportAsync(new IncidentReport(
     private async Task<bool> QueueAutomaticDownloadAsync(
         AnimationInfo info,
         IAnimationInfoRepository animationInfoRepository,
+        IFileMappingRepository fileMappingRepository,
         IFileDownloadClientProvider downloadClientProvider,
         CancellationToken cancellationToken)
     {
         var downloadClient = downloadClientProvider.GetRequiredClient(info.DownloadType);
         var downloadAttemptId = Guid.NewGuid();
+        var submissionLeaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
         var submissionAttempted = false;
         try
         {
-            if (!await animationInfoRepository.TryStartDownloadAsync(
+            var submissionLease = await animationInfoRepository.TryStartDownloadAsync(
                     info.Id,
                     downloadAttemptId,
+                    submissionLeaseId,
+                    DownloadSubmissionLeaseDuration,
                     DateTimeOffset.UtcNow,
                     SubscriptionAutomationDisposition.AutoDownloadQueued,
-                    cancellationToken))
+                    cancellationToken);
+            if (submissionLease is null)
             {
                 LogAutomaticDownloadWarning(logger, info.Title, "download state changed");
                 return false;
             }
 
+            var remainingRemoteBudget = DownloadSubmissionRemoteBudget -
+                                        Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+            if (remainingRemoteBudget <= TimeSpan.Zero)
+            {
+                await CompensateAutomaticStartAsync(
+                    info,
+                    animationInfoRepository,
+                    fileMappingRepository,
+                    downloadClient,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: false);
+                LogAutomaticDownloadWarning(logger, info.Title, "download submission lease expired");
+                return false;
+            }
+
+            using var submissionCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+                cancellationToken);
+            submissionCancellation.CancelAfter(remainingRemoteBudget);
+            submissionCancellation.Token.ThrowIfCancellationRequested();
             submissionAttempted = true;
             if (!await downloadClient.SubmitDownloadTaskAsync(
                     info.Id,
                     info.DownloadUrl,
                     info.CachedDownloadData,
                     info.AdditionalDownloadInfo,
-                    cancellationToken))
+                    submissionCancellation.Token))
             {
                 await CompensateAutomaticStartAsync(
                     info,
                     animationInfoRepository,
+                    fileMappingRepository,
                     downloadClient,
                     downloadAttemptId,
+                    submissionLeaseId,
                     remoteMayHaveAccepted: false);
                 LogAutomaticDownloadWarning(logger, info.Title, "download client rejected the task");
                 return false;
             }
+
+            using var markCancellation = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+            if (!await animationInfoRepository.TryMarkDownloadSubmittedAsync(
+                    info.Id,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    markCancellation.Token))
+            {
+                await CompensateAutomaticStartAsync(
+                    info,
+                    animationInfoRepository,
+                    fileMappingRepository,
+                    downloadClient,
+                    downloadAttemptId,
+                    submissionLeaseId,
+                    remoteMayHaveAccepted: true);
+                LogAutomaticDownloadWarning(logger, info.Title, "download state changed during submission");
+                return false;
+            }
             return true;
         }
         catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
@@ -311,8 +417,10 @@ await CompensateAutomaticStartAsync(
                 await CompensateAutomaticStartAsync(
                     info,
                     animationInfoRepository,
+                    fileMappingRepository,
                     downloadClient,
                     downloadAttemptId,
+                    submissionLeaseId,
                     submissionAttempted);
             }
             catch
@@ -328,8 +436,10 @@ await CompensateAutomaticStartAsync(
                 await CompensateAutomaticStartAsync(
                     info,
                     animationInfoRepository,
+                    fileMappingRepository,
                     downloadClient,
                     downloadAttemptId,
+                    submissionLeaseId,
                     submissionAttempted);
             }
             catch
@@ -344,21 +454,38 @@ await CompensateAutomaticStartAsync(
     private static async Task CompensateAutomaticStartAsync(
         AnimationInfo info,
         IAnimationInfoRepository animationInfoRepository,
+        IFileMappingRepository fileMappingRepository,
         IFileDownloadClient downloadClient,
         Guid downloadAttemptId,
+        Guid submissionLeaseId,
         bool remoteMayHaveAccepted)
     {
         using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        var cancellationAttemptId = Guid.NewGuid();
+        var cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+            info.Id,
+            downloadAttemptId,
+            cancellationAttemptId,
+            submissionLeaseId,
+            DownloadCancellationLeaseDuration,
+            removeFile: false,
+            requireUnfinished: true,
+            SubscriptionAutomationDisposition.AutoDownloadFailed,
+            cleanup.Token);
+        if (cancellationLease is null)
+            return;
+
         if (remoteMayHaveAccepted)
         {
             try
             {
+                cleanup.Token.ThrowIfCancellationRequested();
                 var cancellation = await downloadClient.CancelDownloadTaskAsync(
                     info.Id,
                     info.DownloadUrl,
                     info.CachedDownloadData,
                     info.AdditionalDownloadInfo,
-                    removeFile: false,
+                    cancellationLease.RemoveFile,
                     cleanup.Token);
                 if (!cancellation.IsSuccess)
                 {
@@ -373,9 +500,12 @@ private static async Task CompensateAutomaticStartAsync(
             }
         }
 
-        await animationInfoRepository.TryCancelDownloadAsync(
+        cleanup.Token.ThrowIfCancellationRequested();
+        await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
             info.Id,
             downloadAttemptId,
+            cancellationAttemptId,
+            cancellationLease.Id,
             SubscriptionAutomationDisposition.AutoDownloadFailed,
             cleanup.Token);
     }
diff --git a/SecondDimensionWatcherReDive/Utils/Feed/MikananiSubscriptionFeedReader.cs b/SecondDimensionWatcherReDive/Utils/Feed/MikananiSubscriptionFeedReader.cs
index 680c4cc..8574405 100644
--- a/SecondDimensionWatcherReDive/Utils/Feed/MikananiSubscriptionFeedReader.cs
+++ b/SecondDimensionWatcherReDive/Utils/Feed/MikananiSubscriptionFeedReader.cs
@@ -57,7 +57,9 @@ item.Enclosure is null ||
                 FileDownloadTypes.TorrentDownload,
                 string.Empty,
                 feedId,
-                item.Torrent.ContentLength > 0 ? item.Torrent.ContentLength : null));
+                item.Torrent.ContentLength > 0 ? item.Torrent.ContentLength : null,
+                item.Guid?.Text,
+                item.Enclosure.Url));
         }
 
         return releases;
diff --git a/SecondDimensionWatcherReDive/Utils/Feed/ReleaseScoringService.cs b/SecondDimensionWatcherReDive/Utils/Feed/ReleaseScoringService.cs
new file mode 100644
index 0000000..1b405ac
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Utils/Feed/ReleaseScoringService.cs
@@ -0,0 +1,104 @@
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Framework.Feed;
+
+namespace SecondDimensionWatcherReDive.Utils.Feed;
+
+public sealed class ReleaseScoringService : IReleaseScoringService
+{
+    public ReleaseScore Score(
+        SubscriptionReleaseMetadata metadata,
+        SubscriptionAutomationPolicy? policy)
+    {
+        var reasons = new List<string>();
+        var score = ScoreResolution(metadata.Resolution, reasons) +
+                    ScoreCodec(metadata.Codec, reasons) +
+                    ScoreSubtitleGroup(metadata.SubtitleGroup, policy, reasons) +
+                    ScoreLanguages(metadata.Languages, policy, reasons) +
+                    ScoreSize(metadata.SizeBytes, reasons);
+        return new ReleaseScore(score, reasons);
+    }
+
+    private static int ScoreResolution(string? resolution, ICollection<string> reasons)
+    {
+        var value = resolution?.Trim().ToUpperInvariant() switch
+        {
+            "2160P" or "4K" or "UHD" => 400,
+            "1440P" => 300,
+            "1080P" => 200,
+            "720P" => 100,
+            "576P" => 60,
+            "480P" => 40,
+            _ => 0
+        };
+        if (value > 0) reasons.Add($"resolution:{resolution}:+{value}");
+        return value;
+    }
+
+    private static int ScoreCodec(string? codec, ICollection<string> reasons)
+    {
+        var value = codec?.Trim().ToUpperInvariant() switch
+        {
+            "AV1" => 80,
+            "HEVC" or "H265" or "H.265" => 60,
+            "AVC" or "H264" or "H.264" => 40,
+            "VP9" => 30,
+            _ => 0
+        };
+        if (value > 0) reasons.Add($"codec:{codec}:+{value}");
+        return value;
+    }
+
+    private static int ScoreSubtitleGroup(
+        string? group,
+        SubscriptionAutomationPolicy? policy,
+        ICollection<string> reasons)
+    {
+        if (string.IsNullOrWhiteSpace(group)) return 0;
+        var index = policy?.SubtitleGroups
+            .Select((value, position) => (value, position))
+            .Where(item => string.Equals(
+                item.value.Trim('[', ']', '【', '】'),
+                group.Trim('[', ']', '【', '】'),
+                StringComparison.OrdinalIgnoreCase))
+            .Select(item => (int?)item.position)
+            .FirstOrDefault();
+        var value = policy is { SubtitleGroups.Count: > 0 }
+            ? index is { } position ? Math.Max(10, 50 - position * 5) : 0
+            : 20;
+        reasons.Add($"subtitleGroup:{group}:+{value}");
+        return value;
+    }
+
+    private static int ScoreLanguages(
+        IReadOnlyList<string> languages,
+        SubscriptionAutomationPolicy? policy,
+        ICollection<string> reasons)
+    {
+        var preferred = policy?.Languages ?? [];
+        var score = 0;
+        foreach (var language in languages.Distinct(StringComparer.OrdinalIgnoreCase))
+        {
+            var value = preferred.Count == 0 || preferred.Contains(language, StringComparer.OrdinalIgnoreCase)
+                ? 20
+                : 5;
+            score += value;
+            reasons.Add($"language:{language}:+{value}");
+        }
+        return score;
+    }
+
+    private static int ScoreSize(long? sizeBytes, ICollection<string> reasons)
+    {
+        if (sizeBytes is not > 0) return 0;
+        var gibibytes = sizeBytes.Value / (1024d * 1024 * 1024);
+        var value = gibibytes switch
+        {
+            >= 8 => 40,
+            >= 2 => 25,
+            >= 0.7 => 10,
+            _ => 5
+        };
+        reasons.Add($"size:{gibibytes:F2}GiB:+{value}");
+        return value;
+    }
+}
diff --git a/SecondDimensionWatcherReDive/Utils/FileDownload/FileDownloadClientProxy.cs b/SecondDimensionWatcherReDive/Utils/FileDownload/FileDownloadClientProxy.cs
index 7592653..2dd8567 100644
--- a/SecondDimensionWatcherReDive/Utils/FileDownload/FileDownloadClientProxy.cs
+++ b/SecondDimensionWatcherReDive/Utils/FileDownload/FileDownloadClientProxy.cs
@@ -40,6 +40,19 @@ await _beforeDownloadStartEventTrigger.InvokeAsync(
             cancellationToken);
     }
 
+    public Task<DownloadTaskReconciliationOutcome> EnsureDownloadTaskAsync(
+        Guid itemId,
+        string downloadUrl,
+        byte[] cachedDownloadData,
+        string additionalDownloadInfo,
+        CancellationToken cancellationToken) =>
+        _poxyObject.EnsureDownloadTaskAsync(
+            itemId,
+            downloadUrl,
+            cachedDownloadData,
+            additionalDownloadInfo,
+            cancellationToken);
+
     public async Task SubmitQueryDownloadProgressAsync(
         Guid itemId,
         string downloadUrl,
@@ -108,4 +121,4 @@ public static FileDownloadClientProxy Create(IFileDownloadClient client, IServic
             client,
             serviceProvider.GetRequiredService<IPluginEventTrigger<FileDownloadStartParam>>());
     }
-}
\ No newline at end of file
+}
diff --git a/SecondDimensionWatcherReDive/Utils/FileDownload/RemoteTorrentDownloadClient.cs b/SecondDimensionWatcherReDive/Utils/FileDownload/RemoteTorrentDownloadClient.cs
index 9bb0f72..6583af2 100644
--- a/SecondDimensionWatcherReDive/Utils/FileDownload/RemoteTorrentDownloadClient.cs
+++ b/SecondDimensionWatcherReDive/Utils/FileDownload/RemoteTorrentDownloadClient.cs
@@ -1,4 +1,5 @@
 using System.Threading.Channels;
+using System.Text.Json;
 using SecondDimensionWatcherReDive.Data;
 using SecondDimensionWatcherReDive.Framework.FileDownload;
 using SecondDimensionWatcherReDive.Framework.FileStore;
@@ -23,24 +24,134 @@ public override async Task<bool> SubmitDownloadTaskAsync(
         byte[] cachedDownloadData,
         string additionalDownloadInfo,
         CancellationToken cancellationToken)
+    {
+        using var client = httpClientFactory.CreateClient(nameof(RemoteTorrentDownloadClient));
+        var submission = await SubmitRemoteAsync(
+            client,
+            itemId,
+            cachedDownloadData,
+            additionalDownloadInfo,
+            cancellationToken);
+        if (submission == RemoteSubmissionOutcome.Rejected)
+            return false;
+        if (submission == RemoteSubmissionOutcome.Unknown)
+            throw new HttpRequestException("The qBittorrent submission outcome could not be confirmed.");
+
+        await remoteTorrentTrackRequest.Writer.WriteAsync(
+            new(itemId, additionalDownloadInfo),
+            cancellationToken);
+        return true;
+    }
+
+    public override async Task<DownloadTaskReconciliationOutcome> EnsureDownloadTaskAsync(
+        Guid itemId,
+        string downloadUrl,
+        byte[] cachedDownloadData,
+        string additionalDownloadInfo,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            using var client = httpClientFactory.CreateClient(nameof(RemoteTorrentDownloadClient));
+            if (await IsTorrentPresentAsync(client, additionalDownloadInfo, cancellationToken))
+            {
+                Track(itemId, additionalDownloadInfo);
+                return DownloadTaskReconciliationOutcome.Confirmed;
+            }
+
+            var submission = await SubmitRemoteAsync(
+                client,
+                itemId,
+                cachedDownloadData,
+                additionalDownloadInfo,
+                cancellationToken);
+            if (await ConfirmTorrentAsync(client, additionalDownloadInfo, cancellationToken))
+            {
+                Track(itemId, additionalDownloadInfo);
+                return DownloadTaskReconciliationOutcome.Confirmed;
+            }
+
+            return submission == RemoteSubmissionOutcome.Rejected
+                ? DownloadTaskReconciliationOutcome.Rejected
+                : DownloadTaskReconciliationOutcome.Unknown;
+        }
+        catch (Exception exception) when (exception is HttpRequestException or
+                                          OperationCanceledException or
+                                          JsonException or
+                                          NotSupportedException)
+        {
+            Track(itemId, additionalDownloadInfo);
+            return DownloadTaskReconciliationOutcome.Unknown;
+        }
+    }
+
+    private static async Task<bool> ConfirmTorrentAsync(
+        HttpClient client,
+        string infoHash,
+        CancellationToken cancellationToken)
+    {
+        for (var attempt = 0; attempt < 3; attempt++)
+        {
+            if (await IsTorrentPresentAsync(client, infoHash, cancellationToken))
+                return true;
+            if (attempt < 2)
+                await Task.Delay(TimeSpan.FromMilliseconds(250 * (attempt + 1)), cancellationToken);
+        }
+
+        return false;
+    }
+
+    private async Task<RemoteSubmissionOutcome> SubmitRemoteAsync(
+        HttpClient client,
+        Guid itemId,
+        byte[] cachedDownloadData,
+        string additionalDownloadInfo,
+        CancellationToken cancellationToken)
     {
         using var content = new MultipartFormDataContent();
         content.Add(new ByteArrayContent(cachedDownloadData), "torrent", $"{itemId}.torrent");
         var basePath = Path.GetFullPath(configuration["FileStore:Local"] ?? "./download");
         var savePath = Path.Combine(basePath, additionalDownloadInfo);
         content.Add(new StringContent(savePath), "savepath");
-
-        using var client = httpClientFactory.CreateClient(nameof(RemoteTorrentDownloadClient));
         using var response = await client.PostAsync(
             "/api/v2/torrents/add",
             content,
             cancellationToken);
+        var responseText = (await response.Content.ReadAsStringAsync(cancellationToken)).Trim();
+        if (!response.IsSuccessStatusCode)
+            return (int)response.StatusCode == StatusCodes.Status415UnsupportedMediaType
+                ? RemoteSubmissionOutcome.Rejected
+                : RemoteSubmissionOutcome.Unknown;
+        if (string.Equals(responseText, "Fails.", StringComparison.OrdinalIgnoreCase))
+            return RemoteSubmissionOutcome.Rejected;
+        return string.Equals(responseText, "Ok.", StringComparison.OrdinalIgnoreCase)
+            ? RemoteSubmissionOutcome.Accepted
+            : RemoteSubmissionOutcome.Unknown;
+    }
+
+    private static async Task<bool> IsTorrentPresentAsync(
+        HttpClient client,
+        string infoHash,
+        CancellationToken cancellationToken)
+    {
+        var torrents = await client.GetFromJsonAsync(
+            $"/api/v2/torrents/info?hashes={Uri.EscapeDataString(infoHash)}",
+            QBittorrentJsonSerializerContext.Default.RemoteTorrentInfoArray,
+            cancellationToken);
+        return torrents?.Any(torrent => string.Equals(
+            torrent.Hash,
+            infoHash,
+            StringComparison.OrdinalIgnoreCase)) == true;
+    }
 
-        if (response.IsSuccessStatusCode)
-            await remoteTorrentTrackRequest.Writer.WriteAsync(
-                new(itemId, additionalDownloadInfo));
+    private void Track(Guid itemId, string infoHash) =>
+        remoteTorrentTrackRequest.Writer.TryWrite(new(itemId, infoHash));
 
-        return response.IsSuccessStatusCode;
+    private enum RemoteSubmissionOutcome
+    {
+        Accepted,
+        Rejected,
+        Unknown
     }
 
     public override async Task SubmitQueryDownloadProgressAsync(
@@ -51,7 +162,8 @@ public override async Task SubmitQueryDownloadProgressAsync(
         CancellationToken cancellationToken)
     {
         await remoteTorrentTrackRequest.Writer.WriteAsync(
-            new(itemId, additionalDownloadInfo));
+            new(itemId, additionalDownloadInfo),
+            cancellationToken);
     }
 
     public override async Task<bool> PauseDownloadTaskAsync(
diff --git a/SecondDimensionWatcherReDive/Utils/FileDownload/TorrentDownloadClient.cs b/SecondDimensionWatcherReDive/Utils/FileDownload/TorrentDownloadClient.cs
index a2ee4e1..19bd1f8 100644
--- a/SecondDimensionWatcherReDive/Utils/FileDownload/TorrentDownloadClient.cs
+++ b/SecondDimensionWatcherReDive/Utils/FileDownload/TorrentDownloadClient.cs
@@ -18,6 +18,13 @@ public abstract Task<bool> SubmitDownloadTaskAsync(
         string additionalDownloadInfo,
         CancellationToken cancellationToken);
 
+    public abstract Task<DownloadTaskReconciliationOutcome> EnsureDownloadTaskAsync(
+        Guid itemId,
+        string downloadUrl,
+        byte[] cachedDownloadData,
+        string additionalDownloadInfo,
+        CancellationToken cancellationToken);
+
     public abstract Task SubmitQueryDownloadProgressAsync(
         Guid itemId,
         string downloadUrl,
@@ -46,4 +53,4 @@ public abstract Task<CancelDownloadResult> CancelDownloadTaskAsync(
         string additionalDownloadInfo,
         bool removeFile,
         CancellationToken cancellationToken);
-}
\ No newline at end of file
+}
diff --git a/SecondDimensionWatcherReDive/Utils/Incidents/IncidentRetryService.cs b/SecondDimensionWatcherReDive/Utils/Incidents/IncidentRetryService.cs
index f599b0f..aa51922 100644
--- a/SecondDimensionWatcherReDive/Utils/Incidents/IncidentRetryService.cs
+++ b/SecondDimensionWatcherReDive/Utils/Incidents/IncidentRetryService.cs
@@ -3,6 +3,7 @@
 using SecondDimensionWatcherReDive.Framework.Inference;
 using SecondDimensionWatcherReDive.Framework.Tasks;
 using SecondDimensionWatcherReDive.Utils.FileStore;
+using SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
 
 namespace SecondDimensionWatcherReDive.Utils.Incidents;
 
@@ -13,6 +14,8 @@ public sealed partial class IncidentRetryService(
     IIncidentDiskProbe diskProbe,
     ILogger<IncidentRetryService> logger) : IIncidentRetryService
 {
+    private const string ReleaseUpgradeSourcePrefix = "release-upgrade:";
+
     public async Task<IncidentRetryResult?> RetryAsync(
         Guid id,
         CancellationToken cancellationToken)
@@ -70,29 +73,32 @@ private async Task<IncidentRetryResult> RetryIncidentAsync(
 
         try
         {
-            var status = incident.Type switch
+            var disposition = incident.Type switch
             {
-                IncidentType.FeedFailure => enqueueScheduledTask
-                    ? RetryScheduledTask("SyncFeed", enqueue: true)
-                    : RetryScheduledTask("SyncFeed", enqueue: false),
-                IncidentType.AiFailure => await RetryAiAsync(
-                    incident,
-                    enqueueScheduledTask,
-                    cancellationToken),
+                IncidentType.FeedFailure => RetryDisposition.FromStatus(
+                    enqueueScheduledTask
+                        ? RetryScheduledTask("SyncFeed", enqueue: true)
+                        : RetryScheduledTask("SyncFeed", enqueue: false)),
+                IncidentType.AiFailure => RetryDisposition.FromStatus(
+                    await RetryAiAsync(
+                        incident,
+                        enqueueScheduledTask,
+                        cancellationToken)),
                 IncidentType.FileMappingFailure => await RetryFileMappingAsync(incident, cancellationToken),
-                IncidentType.DownloadStalled => await RetryDownloadAsync(incident, cancellationToken),
-                IncidentType.DiskSpaceLow => await RetryDiskAsync(cancellationToken),
+                IncidentType.DownloadStalled => RetryDisposition.FromStatus(
+                    await RetryDownloadAsync(incident, cancellationToken)),
+                IncidentType.DiskSpaceLow => RetryDisposition.FromStatus(
+                    await RetryDiskAsync(cancellationToken)),
                 _ => throw new ArgumentOutOfRangeException(nameof(incident.Type), incident.Type, null)
             };
 
-            var queued = string.Equals(status, "queued", StringComparison.Ordinal);
             var updated = await incidentRepository.RecordRetryAsync(
                 incident.Id,
                 DateTimeOffset.UtcNow,
                 null,
-                resolve: !queued,
+                disposition.Resolve,
                 cancellationToken);
-            return new IncidentRetryResult(incident.Id, status, true, updated, null);
+            return new IncidentRetryResult(incident.Id, disposition.Status, true, updated, null);
         }
         catch (OperationCanceledException)
         {
@@ -154,10 +160,13 @@ await repository.UpdateAsync(info with
         return "queued";
     }
 
-    private async Task<string> RetryFileMappingAsync(
+    private async Task<RetryDisposition> RetryFileMappingAsync(
         Incident incident,
         CancellationToken cancellationToken)
     {
+        if (TryParseReleaseUpgradeSource(incident.SourceId, out var operationId))
+            return await RetryReleaseUpgradeAsync(operationId, cancellationToken);
+
         if (!Guid.TryParse(incident.SourceId, out var animationInfoId))
             throw new InvalidOperationException("Mapping incident source is not a valid animation id.");
 
@@ -165,7 +174,127 @@ private async Task<string> RetryFileMappingAsync(
         var mapper = scope.ServiceProvider.GetRequiredService<IFileMapper>();
         if (!await mapper.MapDownloadAsync(animationInfoId, cancellationToken))
             throw new InvalidOperationException("No file mapping could be produced.");
-        return "resolved";
+        return RetryDisposition.FromStatus("resolved");
+    }
+
+    private async Task<RetryDisposition> RetryReleaseUpgradeAsync(
+        Guid operationId,
+        CancellationToken cancellationToken)
+    {
+        await using var scope = scopeFactory.CreateAsyncScope();
+        var repository = scope.ServiceProvider.GetRequiredService<IReleaseUpgradeRepository>();
+        var coordinator = scope.ServiceProvider.GetRequiredService<IReleaseUpgradeCoordinator>();
+        var operation = await repository.FindByIdAsync(operationId, cancellationToken);
+        for (var stateRead = 0; stateRead < 2; stateRead++)
+        {
+            if (operation is null)
+                return RetryDisposition.FromStatus("resolved");
+
+            switch (operation.Status)
+            {
+                case ReleaseUpgradeStatus.Downloading:
+                case ReleaseUpgradeStatus.Verifying:
+                    {
+                        var result = await coordinator.TryActivateCandidateAsync(
+                            operation.CandidateReleaseId,
+                            cancellationToken);
+                        if (result is not null)
+                            return RetryDisposition.FromStatus(NormalizeReleaseUpgradeRetry(result));
+
+                        operation = await repository.FindByIdAsync(operationId, cancellationToken);
+                        continue;
+                    }
+                case ReleaseUpgradeStatus.Failed:
+                    {
+                        var candidate = await repository.FindCandidateAsync(
+                            operation.CurrentReleaseId,
+                            operation.CandidateReleaseId,
+                            cancellationToken);
+                        if (candidate is null)
+                            return RetryDisposition.FromStatus("resolved");
+
+                        var result = await coordinator.ExecuteAsync(
+                            candidate,
+                            dryRun: false,
+                            cancellationToken);
+                        if (result.Operation is { } replacement && replacement.Id != operation.Id)
+                        {
+                            var replacementIsActive = replacement.Status is
+                                ReleaseUpgradeStatus.Downloading or ReleaseUpgradeStatus.Verifying;
+                            return new RetryDisposition(
+                                replacementIsActive ? "queued" : "resolved",
+                                Resolve: true);
+                        }
+
+                        return RetryDisposition.FromStatus(NormalizeReleaseUpgradeRetry(result));
+                    }
+                case ReleaseUpgradeStatus.Applied:
+                    {
+                        if (operation.RollbackUntil is not { } rollbackUntil ||
+                            rollbackUntil < DateTimeOffset.UtcNow)
+                            return RetryDisposition.FromStatus("resolved");
+
+                        var result = await coordinator.RollbackAsync(operation.Id, cancellationToken);
+                        if (!result.IsSuccess)
+                            throw new InvalidOperationException(
+                                $"Release upgrade rollback retry failed: {result.Outcome}.");
+                        return RetryDisposition.FromStatus("resolved");
+                    }
+                case ReleaseUpgradeStatus.RolledBack:
+                case ReleaseUpgradeStatus.Completed:
+                    return RetryDisposition.FromStatus("resolved");
+                default:
+                    throw new ArgumentOutOfRangeException(
+                        nameof(operation.Status),
+                        operation.Status,
+                        null);
+            }
+        }
+
+        return RetryDisposition.FromStatus("queued");
+    }
+
+    private static string NormalizeReleaseUpgradeRetry(ReleaseUpgradeExecutionResult result)
+    {
+        if (!result.IsSuccess)
+        {
+            if (result.Outcome is "recovery_pending" or "upgrade_already_started")
+                return "queued";
+
+            var detail = result.ValidationErrors.FirstOrDefault();
+            throw new InvalidOperationException(string.IsNullOrWhiteSpace(detail)
+                ? $"Release upgrade retry failed: {result.Outcome}."
+                : detail);
+        }
+
+        return result.Outcome is
+            "download_queued" or
+            "download_in_progress" or
+            "download_submission_in_progress" or
+            "download_submission_recovered" or
+            "mapping_pending"
+                ? "queued"
+                : "resolved";
+    }
+
+    private static bool TryParseReleaseUpgradeSource(string sourceId, out Guid operationId)
+    {
+        if (sourceId.StartsWith(ReleaseUpgradeSourcePrefix, StringComparison.Ordinal) &&
+            Guid.TryParseExact(
+                sourceId.AsSpan(ReleaseUpgradeSourcePrefix.Length),
+                "N",
+                out operationId))
+            return true;
+
+        operationId = default;
+        return false;
+    }
+
+    private readonly record struct RetryDisposition(string Status, bool Resolve)
+    {
+        public static RetryDisposition FromStatus(string status) => new(
+            status,
+            !string.Equals(status, "queued", StringComparison.Ordinal));
     }
 
     private async Task<string> RetryDownloadAsync(
diff --git a/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/IReleaseUpgradeCoordinator.cs b/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/IReleaseUpgradeCoordinator.cs
new file mode 100644
index 0000000..fab095a
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/IReleaseUpgradeCoordinator.cs
@@ -0,0 +1,39 @@
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+
+namespace SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
+
+public sealed record ReleaseUpgradeExecutionResult(
+    bool IsSuccess,
+    string Outcome,
+    bool DryRun,
+    bool RequiresDownload,
+    ReleaseUpgradeOperation? Operation,
+    IReadOnlyList<string> ValidationErrors);
+
+public interface IReleaseUpgradeCoordinator
+{
+    Task<ReleaseUpgradeExecutionResult> ExecuteAsync(
+        ReleaseUpgradeCandidate candidate,
+        bool dryRun,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeExecutionResult?> TryActivateCandidateAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken);
+
+    Task ReconcilePendingDownloadCancellationAsync(
+        ReleaseUpgradePendingDownloadCancellation pendingCancellation,
+        CancellationToken cancellationToken);
+
+    Task ReconcilePendingDownloadCancellationAsync(
+        PendingDownloadCancellation pendingCancellation,
+        CancellationToken cancellationToken);
+
+    Task ReconcilePendingDownloadSubmissionAsync(
+        PendingDownloadSubmission pendingSubmission,
+        CancellationToken cancellationToken);
+
+    Task<ReleaseUpgradeMutationResult> RollbackAsync(
+        Guid operationId,
+        CancellationToken cancellationToken);
+}
diff --git a/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/ReleaseUpgradeCoordinator.cs b/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/ReleaseUpgradeCoordinator.cs
new file mode 100644
index 0000000..d115c75
--- /dev/null
+++ b/SecondDimensionWatcherReDive/Utils/ReleaseUpgrades/ReleaseUpgradeCoordinator.cs
@@ -0,0 +1,943 @@
+using System.Diagnostics;
+using SecondDimensionWatcherReDive.Framework.DataRepository;
+using SecondDimensionWatcherReDive.Framework.FileDownload;
+using SecondDimensionWatcherReDive.Framework.FileStore;
+using SecondDimensionWatcherReDive.Framework.PluginParams;
+using SecondDimensionWatcherReDive.Plugin;
+using SecondDimensionWatcherReDive.Utils.FileStore;
+using SecondDimensionWatcherReDive.Utils.Incidents;
+
+namespace SecondDimensionWatcherReDive.Utils.ReleaseUpgrades;
+
+public sealed class ReleaseUpgradeCoordinator(
+    IReleaseUpgradeRepository upgradeRepository,
+    IAnimationInfoRepository animationInfoRepository,
+    ISubscriptionAutomationPolicyRepository policyRepository,
+    IFileMappingRepository fileMappingRepository,
+    IFileDownloadClientProvider downloadClientProvider,
+    IFileStoreProvider fileStoreProvider,
+    IPluginEventTrigger<FileDownloadStartParam> beforeDownloadStartEventTrigger,
+    IIncidentReporter incidentReporter,
+    ILogger<ReleaseUpgradeCoordinator> logger) : IReleaseUpgradeCoordinator
+{
+    private static readonly TimeSpan DownloadSubmissionLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadSubmissionRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadCancellationLeaseDuration = TimeSpan.FromMinutes(3);
+    private static readonly TimeSpan DownloadCancellationRemoteBudget = TimeSpan.FromSeconds(90);
+    private static readonly TimeSpan DownloadCancellationRetryDelay = TimeSpan.FromMinutes(2);
+    private static readonly TimeSpan DownloadLeaseSafetyMargin = TimeSpan.FromSeconds(1);
+
+    public async Task<ReleaseUpgradeExecutionResult> ExecuteAsync(
+        ReleaseUpgradeCandidate candidate,
+        bool dryRun,
+        CancellationToken cancellationToken)
+    {
+        var next = await animationInfoRepository.FindByIdAsync(
+            candidate.CandidateReleaseId,
+            cancellationToken);
+        if (next is null)
+            return Result(false, "candidate_not_found", dryRun, false, null, ["Candidate release does not exist."]);
+
+        var requiresDownload = !next.IsDownloadFinished;
+        if (dryRun)
+        {
+            var validationErrors = requiresDownload
+                ? Array.Empty<string>()
+                : await ValidateCandidateAsync(candidate, cancellationToken);
+            return Result(validationErrors.Count == 0,
+                validationErrors.Count == 0 ? "ready" : "validation_failed",
+                true,
+                requiresDownload,
+                null,
+                validationErrors);
+        }
+
+        var operation = await upgradeRepository.TryBeginAsync(
+            candidate,
+            DateTimeOffset.UtcNow,
+            cancellationToken);
+        if (operation is null)
+            return Result(false, "upgrade_already_started", false, requiresDownload, null,
+                ["Another worker already claimed this upgrade."]);
+
+        return await ContinueOperationAsync(operation, cancellationToken);
+    }
+
+    public async Task<ReleaseUpgradeExecutionResult?> TryActivateCandidateAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var operation = await upgradeRepository.FindActiveByCandidateAsync(
+            candidateReleaseId,
+            cancellationToken);
+        return operation is null
+            ? null
+            : await ContinueOperationAsync(operation, cancellationToken);
+    }
+
+    public Task ReconcilePendingDownloadCancellationAsync(
+        ReleaseUpgradePendingDownloadCancellation pendingCancellation,
+        CancellationToken cancellationToken) =>
+        ReconcilePendingDownloadCancellationCoreAsync(
+            pendingCancellation.CandidateReleaseId,
+            pendingCancellation.RemoveFile,
+            pendingCancellation,
+            cancellationToken);
+
+    public Task ReconcilePendingDownloadCancellationAsync(
+        PendingDownloadCancellation pendingCancellation,
+        CancellationToken cancellationToken) =>
+        ReconcilePendingDownloadCancellationCoreAsync(
+            pendingCancellation.AnimationInfoId,
+            pendingCancellation.RemoveFile,
+            upgradeCancellation: null,
+            cancellationToken);
+
+    public async Task ReconcilePendingDownloadSubmissionAsync(
+        PendingDownloadSubmission pendingSubmission,
+        CancellationToken cancellationToken)
+    {
+        var info = await animationInfoRepository.FindByIdAsync(
+            pendingSubmission.AnimationInfoId,
+            cancellationToken);
+        if (info is null ||
+            !info.IsDownloadTracked ||
+            info.IsDownloadFinished ||
+            info.DownloadAttemptId != pendingSubmission.DownloadAttemptId ||
+            info.DownloadCancellationId is not null)
+            return;
+
+        var cancellationAttemptId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
+        var cancellationLease = await animationInfoRepository
+            .TryBeginExpiredDownloadSubmissionRecoveryAsync(
+            info.Id,
+            pendingSubmission.DownloadAttemptId,
+            pendingSubmission.SubmissionLeaseId,
+            cancellationAttemptId,
+            Guid.NewGuid(),
+            DownloadCancellationLeaseDuration,
+            info.AutomationDisposition == SubscriptionAutomationDisposition.AutoDownloadQueued
+                ? SubscriptionAutomationDisposition.AutoDownloadFailed
+                : null,
+            cancellationToken);
+        if (cancellationLease is null)
+            return;
+
+        await TryReconcileClaimedCancellationAsync(
+            info,
+            pendingSubmission.DownloadAttemptId,
+            cancellationAttemptId,
+            cancellationLease,
+            leaseRequestStartedAt,
+            cancellationToken);
+    }
+
+    private async Task ReconcilePendingDownloadCancellationCoreAsync(
+        Guid animationInfoId,
+        bool removeFile,
+        ReleaseUpgradePendingDownloadCancellation? upgradeCancellation,
+        CancellationToken cancellationToken)
+    {
+        var info = await animationInfoRepository.FindByIdAsync(
+            animationInfoId,
+            cancellationToken);
+        if (info?.DownloadCancellationId is not { } cancellationAttemptId)
+            return;
+
+        Guid? downloadAttemptId = info.IsDownloadTracked
+            ? info.DownloadAttemptId
+            : Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
+        var cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+                info.Id,
+                downloadAttemptId,
+                cancellationAttemptId,
+                Guid.NewGuid(),
+                DownloadCancellationLeaseDuration,
+                removeFile,
+                requireUnfinished: false,
+                terminalDisposition: null,
+                cancellationToken);
+        if (cancellationLease is null)
+        {
+            if (upgradeCancellation is not null)
+                await DeferDownloadCancellationSafelyAsync(
+                    upgradeCancellation,
+                    cancellationToken);
+            return;
+        }
+
+        if (!await TryReconcileClaimedCancellationAsync(
+                info,
+                downloadAttemptId,
+                cancellationAttemptId,
+                cancellationLease,
+                leaseRequestStartedAt,
+                cancellationToken))
+            return;
+
+        if (upgradeCancellation is not null)
+            await upgradeRepository.TryMarkDownloadCancellationReconciledAsync(
+                upgradeCancellation.OperationId,
+                upgradeCancellation.SubmissionLeaseId,
+                cancellationToken);
+    }
+
+    private async Task<bool> TryReconcileClaimedCancellationAsync(
+        AnimationInfo info,
+        Guid? downloadAttemptId,
+        Guid cancellationAttemptId,
+        DownloadCancellationLease cancellationLease,
+        long leaseRequestStartedAt,
+        CancellationToken cancellationToken)
+    {
+        var client = downloadClientProvider.GetRequiredClient(info.DownloadType);
+        var remainingRemoteBudget = DownloadCancellationRemoteBudget -
+                                    Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+        if (remainingRemoteBudget <= TimeSpan.Zero)
+            return false;
+        using var remoteCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+            cancellationToken);
+        remoteCancellation.CancelAfter(remainingRemoteBudget);
+        remoteCancellation.Token.ThrowIfCancellationRequested();
+        var cancellation = await client.CancelDownloadTaskAsync(
+            info.Id,
+            info.DownloadUrl,
+            info.CachedDownloadData,
+            info.AdditionalDownloadInfo,
+            cancellationLease.RemoveFile,
+            remoteCancellation.Token);
+        if (!cancellation.IsSuccess)
+        {
+            await QueryDownloadProgressSafelyAsync(client, info, cancellationToken);
+            return false;
+        }
+
+        using var finalizeCancellation = CreateLeaseBoundTokenSource(
+            cancellationToken,
+            leaseRequestStartedAt,
+            DownloadCancellationLeaseDuration);
+        if (finalizeCancellation is null)
+            return false;
+        if (!await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
+                info.Id,
+                downloadAttemptId,
+                cancellationAttemptId,
+                cancellationLease.Id,
+                terminalDisposition: null,
+                finalizeCancellation.Token))
+            return false;
+        return true;
+    }
+
+    private async Task DeferDownloadCancellationSafelyAsync(
+        ReleaseUpgradePendingDownloadCancellation pendingCancellation,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await upgradeRepository.TryDeferDownloadCancellationAsync(
+                pendingCancellation.OperationId,
+                pendingCancellation.SubmissionLeaseId,
+                DownloadCancellationRetryDelay,
+                cancellationToken);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(
+                exception,
+                "Could not defer release-upgrade cancellation reconciliation for operation {OperationId}",
+                pendingCancellation.OperationId);
+        }
+    }
+
+    private async Task<ReleaseUpgradeExecutionResult> ContinueOperationAsync(
+        ReleaseUpgradeOperation operation,
+        CancellationToken cancellationToken)
+    {
+        if (operation.Status == ReleaseUpgradeStatus.Verifying)
+            return await ActivateAsync(operation.CandidateReleaseId, cancellationToken);
+
+        var next = await animationInfoRepository.FindByIdAsync(
+            operation.CandidateReleaseId,
+            cancellationToken);
+        if (next is null)
+            return await FailAsync(operation, "Candidate release disappeared after claim.", cancellationToken);
+        if (next.IsDownloadFinished)
+            return await ActivateAsync(operation.CandidateReleaseId, cancellationToken);
+        if (next.IsDownloadTracked &&
+            next.DownloadCancellationId is null &&
+            operation.DownloadSubmittedAt is not null)
+            return Result(true, "download_in_progress", false, true, operation, []);
+        if (next.DownloadCancellationId is not null)
+            return await FailAsync(operation, "Candidate download cancellation is in progress.", cancellationToken);
+
+        var leaseId = Guid.NewGuid();
+        var leaseRequestStartedAt = Stopwatch.GetTimestamp();
+        var lease = await upgradeRepository.TryClaimDownloadSubmissionAsync(
+                operation.Id,
+                leaseId,
+                DownloadSubmissionLeaseDuration,
+                cancellationToken);
+        if (lease is null)
+            return Result(true, "download_submission_in_progress", false, true, operation, []);
+
+        var downloadAttemptId = next.DownloadAttemptId ?? Guid.NewGuid();
+        var recoveringPersistedSubmission = next.IsDownloadTracked;
+        IFileDownloadClient? client = null;
+        var preparationAttempted = false;
+        var downloadStartAttempted = false;
+        var submissionAttempted = false;
+        var submissionUncertain = false;
+        try
+        {
+            var remainingRemoteBudget = DownloadSubmissionRemoteBudget -
+                                        Stopwatch.GetElapsedTime(leaseRequestStartedAt);
+            if (remainingRemoteBudget <= TimeSpan.Zero)
+                return await RecoveryPendingAsync(
+                    operation,
+                    "The durable submission lease was acquired too late to begin remote reconciliation safely.",
+                    cancellationToken);
+            using var submissionCancellation = CancellationTokenSource.CreateLinkedTokenSource(
+                cancellationToken);
+            submissionCancellation.CancelAfter(remainingRemoteBudget);
+            client = downloadClientProvider.GetRequiredClient(next.DownloadType);
+            if (!lease.IsPrepared)
+            {
+                preparationAttempted = true;
+                await beforeDownloadStartEventTrigger.InvokeAsync(
+                    new FileDownloadStartParam(
+                        next.Id,
+                        next.DownloadUrl,
+                        next.CachedDownloadData,
+                        next.AdditionalDownloadInfo),
+                    submissionCancellation.Token);
+                if (!await upgradeRepository.TryMarkDownloadPreparedAsync(
+                        operation.Id,
+                        leaseId,
+                        DateTimeOffset.UtcNow,
+                        submissionCancellation.Token))
+                    return Result(
+                        true,
+                        "download_submission_in_progress",
+                        false,
+                        true,
+                        operation,
+                        []);
+            }
+
+            if (!next.IsDownloadTracked)
+            {
+                downloadStartAttempted = true;
+                if (!await animationInfoRepository.TryStartUpgradeDownloadAsync(
+                        next.Id,
+                        operation.Id,
+                        downloadAttemptId,
+                        DateTimeOffset.UtcNow,
+                        SubscriptionAutomationDisposition.AutoDownloadQueued,
+                        cancellationToken))
+                {
+                    var racedCandidate = await animationInfoRepository.FindByIdAsync(
+                        next.Id,
+                        cancellationToken);
+                    if (racedCandidate?.IsDownloadFinished == true)
+                        return await ActivateAsync(operation.CandidateReleaseId, cancellationToken);
+                    if (racedCandidate?.IsDownloadTracked != true ||
+                        racedCandidate.DownloadCancellationId is not null ||
+                        racedCandidate.DownloadAttemptId is not { } racedAttemptId)
+                        return await FailAsync(operation, "Candidate download state changed.", cancellationToken);
+
+                    next = racedCandidate;
+                    downloadAttemptId = racedAttemptId;
+                    recoveringPersistedSubmission = true;
+                }
+            }
+
+            submissionAttempted = true;
+            var reconciliation = await client.EnsureDownloadTaskAsync(
+                next.Id,
+                next.DownloadUrl,
+                next.CachedDownloadData,
+                next.AdditionalDownloadInfo,
+                submissionCancellation.Token);
+            if (reconciliation == DownloadTaskReconciliationOutcome.Unknown)
+            {
+                submissionUncertain = true;
+                return await RecoveryPendingAsync(
+                    operation,
+                    "The candidate submission could not yet be confirmed remotely.",
+                    cancellationToken);
+            }
+            if (reconciliation == DownloadTaskReconciliationOutcome.Rejected)
+            {
+                var compensation = await CompensateDownloadStartAsync(
+                    next,
+                    client,
+                    recoveringPersistedSubmission ? next.DownloadAttemptId : downloadAttemptId,
+                    remoteMayHaveAccepted: true);
+                if (compensation == DownloadCompensationOutcome.RetainedForRecovery)
+                    return await RecoveryPendingAsync(
+                        operation,
+                        "The remote client rejected the candidate, but durable cancellation is still pending.",
+                        cancellationToken);
+                return await FailAsync(
+                    operation,
+                    "The remote client rejected the candidate submission.",
+                    cancellationToken);
+            }
+
+            if (reconciliation != DownloadTaskReconciliationOutcome.Confirmed)
+            {
+                submissionUncertain = true;
+                return await RecoveryPendingAsync(
+                    operation,
+                    "The candidate submission remains unresolved.",
+                    cancellationToken);
+            }
+
+            var markOutcome = await upgradeRepository.TryMarkDownloadSubmittedAsync(
+                operation.Id,
+                leaseId,
+                recoveringPersistedSubmission ? next.DownloadAttemptId : downloadAttemptId,
+                DateTimeOffset.UtcNow,
+                cancellationToken);
+            if (markOutcome == ReleaseUpgradeDownloadSubmissionMarkOutcome.LeaseLost)
+                return Result(
+                    true,
+                    "download_submission_in_progress",
+                    false,
+                    true,
+                    operation,
+                    []);
+            if (markOutcome is ReleaseUpgradeDownloadSubmissionMarkOutcome.StateChanged or
+                ReleaseUpgradeDownloadSubmissionMarkOutcome.NotFound)
+            {
+                var current = await animationInfoRepository.FindByIdAsync(
+                    next.Id,
+                    cancellationToken);
+                if (current?.DownloadCancellationId is not null)
+                    return await RecoveryPendingAsync(
+                        operation,
+                        "The download was submitted while cancellation was in progress; durable cleanup is pending.",
+                        cancellationToken);
+                return Result(
+                    false,
+                    "upgrade_no_longer_active",
+                    false,
+                    true,
+                    operation,
+                    ["The download continues independently because the upgrade operation changed state."]);
+            }
+
+            return Result(
+                true,
+                recoveringPersistedSubmission ? "download_submission_recovered" : "download_queued",
+                false,
+                true,
+                operation,
+                []);
+        }
+        catch (HttpRequestException exception)
+        {
+            logger.LogWarning(
+                exception,
+                "Remote submission response was uncertain for release upgrade {OperationId}",
+                operation.Id);
+            return await RecoveryPendingAsync(
+                operation,
+                $"{exception.Message} Remote submission reconciliation will be retried.",
+                cancellationToken);
+        }
+        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested &&
+                                                 (preparationAttempted || submissionAttempted))
+        {
+            return await RecoveryPendingAsync(
+                operation,
+                "The remote submission deadline elapsed; reconciliation will resume after the durable lease expires.",
+                cancellationToken);
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            if (recoveringPersistedSubmission || submissionUncertain)
+                throw;
+
+            var compensation = downloadStartAttempted
+                ? await CompensateDownloadStartAsync(
+                    next,
+                    client,
+                    downloadAttemptId,
+                    submissionAttempted)
+                : DownloadCompensationOutcome.LocalStateRestored;
+            await FinalizeCancelledOperationAsync(operation, compensation);
+
+            throw;
+        }
+        catch (Exception exception)
+        {
+            if (recoveringPersistedSubmission || submissionUncertain)
+            {
+                logger.LogWarning(
+                    exception,
+                    "Could not reconcile persisted download submission for release upgrade {OperationId}",
+                    operation.Id);
+                return await RecoveryPendingAsync(
+                    operation,
+                    $"{exception.Message} The persisted submission will be retried after its lease expires.",
+                    cancellationToken);
+            }
+
+            var compensation = downloadStartAttempted
+                ? await CompensateDownloadStartAsync(
+                    next,
+                    client,
+                    downloadAttemptId,
+                    submissionAttempted)
+                : DownloadCompensationOutcome.LocalStateRestored;
+
+            logger.LogWarning(exception, "Failed to queue release upgrade {OperationId}", operation.Id);
+            if (compensation == DownloadCompensationOutcome.RetainedForRecovery)
+                return await RecoveryPendingAsync(
+                    operation,
+                    $"{exception.Message} Download tracking was retained because cancellation could not be confirmed.",
+                    cancellationToken);
+            return await FailAsync(operation, exception.Message, cancellationToken);
+        }
+    }
+
+    public async Task<ReleaseUpgradeMutationResult> RollbackAsync(
+        Guid operationId,
+        CancellationToken cancellationToken)
+    {
+        var rolledBackAt = DateTimeOffset.UtcNow;
+        var rollback = await upgradeRepository.GetRollbackAsync(operationId, cancellationToken);
+        if (rollback?.Operation.RollbackUntil >= rolledBackAt)
+        {
+            var errors = await ValidateReadableMappingsAsync(
+                rollback.PreviousMappings,
+                requireVideo: true,
+                cancellationToken);
+            if (errors.Count > 0)
+            {
+                var summary = string.Join(" ", errors);
+                await incidentReporter.ReportAsync(new IncidentReport(
+                        IncidentType.FileMappingFailure,
+                        IncidentSeverity.Error,
+                        "Release upgrade rollback validation failed",
+                        summary,
+                        UpgradeSource(operationId)),
+                    cancellationToken);
+                return new ReleaseUpgradeMutationResult(
+                    false,
+                    "rollback_validation_failed",
+                    rollback.Operation);
+            }
+        }
+
+        var result = await upgradeRepository.RollbackAsync(
+            operationId,
+            rolledBackAt,
+            cancellationToken);
+        if (result.IsSuccess)
+        {
+            await incidentReporter.ResolveAsync(
+                IncidentType.FileMappingFailure,
+                UpgradeSource(operationId),
+                cancellationToken);
+        }
+
+        return result;
+    }
+
+    private async Task<ReleaseUpgradeExecutionResult> ActivateAsync(
+        Guid candidateReleaseId,
+        CancellationToken cancellationToken)
+    {
+        var activation = await upgradeRepository.GetActivationAsync(
+            candidateReleaseId,
+            cancellationToken);
+        if (activation is null)
+            return Result(false, "operation_not_found", false, false, null,
+                ["No active upgrade was found for this candidate."]);
+        if (activation.CandidateMappings.Count == 0)
+            return Result(true, "mapping_pending", false, false, activation.Operation, []);
+
+        // Validation is deliberately external to the mapping transaction. Until every
+        // candidate file passes, the old virtual paths and physical files remain untouched.
+        var validationErrors = await ValidateActivationAsync(activation, cancellationToken);
+        if (validationErrors.Count > 0)
+            return await FailAsync(activation.Operation, string.Join(" ", validationErrors), cancellationToken,
+                validationErrors);
+
+        var candidate = await animationInfoRepository.FindByIdAsync(candidateReleaseId, cancellationToken);
+        var rollbackHours = 72;
+        if (candidate?.SourceFeedId is { } feedId)
+        {
+            var policy = await policyRepository.FindByFeedIdAsync(feedId, cancellationToken);
+            rollbackHours = policy?.UpgradeRollbackHours ?? rollbackHours;
+        }
+
+        var now = DateTimeOffset.UtcNow;
+        var mutation = await upgradeRepository.ActivateAsync(
+            activation.Operation.Id,
+            activation.PreviousMappings,
+            activation.CandidateMappings,
+            now,
+            now.AddHours(rollbackHours),
+            cancellationToken);
+        if (!mutation.IsSuccess)
+            return await FailAsync(activation.Operation,
+                $"Atomic mapping swap failed: {mutation.Outcome}.",
+                cancellationToken);
+
+        await incidentReporter.ResolveAsync(
+            IncidentType.FileMappingFailure,
+            UpgradeSource(activation.Operation.Id),
+            cancellationToken);
+        return Result(true, mutation.Outcome, false, false, mutation.Operation, []);
+    }
+
+    private async Task<IReadOnlyList<string>> ValidateCandidateAsync(
+        ReleaseUpgradeCandidate candidate,
+        CancellationToken cancellationToken)
+    {
+        var previous = await fileMappingRepository.GetForAnimationInfoAsync(
+            candidate.CurrentReleaseId,
+            cancellationToken);
+        var next = await upgradeRepository.GetCandidateMappingsAsync(
+            candidate.CandidateReleaseId,
+            cancellationToken);
+        return await ValidateMappingsAsync(previous, next, cancellationToken);
+    }
+
+    private async Task<IReadOnlyList<string>> ValidateActivationAsync(
+        ReleaseUpgradeActivation activation,
+        CancellationToken cancellationToken) =>
+        await ValidateMappingsAsync(
+            activation.PreviousMappings,
+            activation.CandidateMappings,
+            cancellationToken);
+
+    private async Task<IReadOnlyList<string>> ValidateMappingsAsync(
+        IReadOnlyList<FileMapping> previousMappings,
+        IReadOnlyList<FileMapping> candidateMappings,
+        CancellationToken cancellationToken)
+    {
+        var errors = new List<string>();
+        if (previousMappings.Count == 0)
+            errors.Add("The current release has no mapping to preserve.");
+        if (candidateMappings.Count == 0)
+            errors.Add("The candidate release has no mapped files.");
+
+        errors.AddRange(await ValidateReadableMappingsAsync(
+            candidateMappings,
+            requireVideo: true,
+            cancellationToken));
+        return errors;
+    }
+
+    private async Task<IReadOnlyList<string>> ValidateReadableMappingsAsync(
+        IReadOnlyList<FileMapping> mappings,
+        bool requireVideo,
+        CancellationToken cancellationToken)
+    {
+        var errors = new List<string>();
+        var readableFiles = 0;
+        var readableVideos = 0;
+        foreach (var mapping in mappings)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            try
+            {
+                var store = fileStoreProvider.GetRequiredClient(mapping.FileStore);
+                if (!await store.ExistAsync(mapping.PhysicalPath, cancellationToken))
+                {
+                    errors.Add($"Release file is missing: {mapping.PhysicalPath}");
+                    continue;
+                }
+
+                var info = await store.FileInfoAsync(mapping.PhysicalPath, cancellationToken);
+                if (info.IsDirectory || info.Length is <= 0)
+                    errors.Add($"Release file is not a readable non-empty file: {mapping.PhysicalPath}");
+                else
+                {
+                    readableFiles++;
+                    if (MediaFileTypes.IsVideo(mapping.PhysicalPath))
+                        readableVideos++;
+                }
+            }
+            catch (Exception exception) when (exception is not OperationCanceledException)
+            {
+                errors.Add($"Release file validation failed for {mapping.PhysicalPath}: {exception.Message}");
+            }
+        }
+
+        if (mappings.Count > 0 && readableFiles == 0)
+            errors.Add("Release validation found no readable file.");
+        if (requireVideo && mappings.Count > 0 && readableVideos == 0)
+            errors.Add("Release validation found no readable video file.");
+        return errors;
+    }
+
+    private async Task<ReleaseUpgradeExecutionResult> FailAsync(
+        ReleaseUpgradeOperation operation,
+        string summary,
+        CancellationToken cancellationToken,
+        IReadOnlyList<string>? errors = null)
+    {
+        var mutation = await upgradeRepository.MarkFailedAsync(
+            operation.Id,
+            summary,
+            cancellationToken);
+        if (!mutation.IsSuccess)
+        {
+            var settled = mutation.Operation?.Status is
+                ReleaseUpgradeStatus.Applied or
+                ReleaseUpgradeStatus.Completed or
+                ReleaseUpgradeStatus.RolledBack;
+            return Result(
+                settled,
+                settled ? "already_settled" : mutation.Outcome,
+                false,
+                false,
+                mutation.Operation ?? operation,
+                errors ?? [summary]);
+        }
+
+        await incidentReporter.ReportAsync(new IncidentReport(
+                IncidentType.FileMappingFailure,
+                IncidentSeverity.Error,
+                "Release upgrade failed",
+                summary,
+                UpgradeSource(operation.Id)),
+            cancellationToken);
+        return Result(false, "failed", false, false, mutation.Operation ?? operation,
+            errors ?? [summary]);
+    }
+
+    private async Task<ReleaseUpgradeExecutionResult> RecoveryPendingAsync(
+        ReleaseUpgradeOperation operation,
+        string summary,
+        CancellationToken cancellationToken)
+    {
+        await incidentReporter.ReportAsync(new IncidentReport(
+                IncidentType.FileMappingFailure,
+                IncidentSeverity.Error,
+                "Release upgrade download recovery pending",
+                summary,
+                UpgradeSource(operation.Id)),
+            cancellationToken);
+        return Result(false, "recovery_pending", false, true, operation, [summary]);
+    }
+
+    private async Task FinalizeCancelledOperationAsync(
+        ReleaseUpgradeOperation operation,
+        DownloadCompensationOutcome compensation)
+    {
+        using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        var summary = compensation == DownloadCompensationOutcome.LocalStateRestored
+            ? "Release upgrade request was cancelled and its download state was restored."
+            : "Release upgrade request was cancelled, but download tracking was retained for recovery.";
+        try
+        {
+            if (compensation == DownloadCompensationOutcome.LocalStateRestored)
+                await upgradeRepository.MarkFailedAsync(operation.Id, summary, cleanup.Token);
+            await incidentReporter.ReportAsync(new IncidentReport(
+                    IncidentType.FileMappingFailure,
+                    IncidentSeverity.Error,
+                    compensation == DownloadCompensationOutcome.LocalStateRestored
+                        ? "Release upgrade cancelled"
+                        : "Release upgrade download recovery pending",
+                    summary,
+                    UpgradeSource(operation.Id)),
+                cleanup.Token);
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(
+                exception,
+                "Could not finalize cancelled release upgrade {OperationId}",
+                operation.Id);
+        }
+    }
+
+    private async Task<DownloadCompensationOutcome> CompensateDownloadStartAsync(
+        AnimationInfo info,
+        IFileDownloadClient? downloadClient,
+        Guid? downloadAttemptId,
+        bool remoteMayHaveAccepted)
+    {
+        using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+        var cancellationAttemptId = Guid.NewGuid();
+        DownloadCancellationLease? cancellationLease;
+        try
+        {
+            // Register cancellation before any remote I/O. Activation and the
+            // cancellation saga share the mapping lock, so an activation that
+            // already committed makes this return false and its live files are
+            // never deleted by stale compensation.
+            cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+                    info.Id,
+                    downloadAttemptId,
+                    cancellationAttemptId,
+                    Guid.NewGuid(),
+                    DownloadCancellationLeaseDuration,
+                    removeFile: false,
+                    requireUnfinished: true,
+                    SubscriptionAutomationDisposition.AutoDownloadFailed,
+                    cleanup.Token);
+            if (cancellationLease is null)
+            {
+                var current = await animationInfoRepository.FindByIdAsync(
+                    info.Id,
+                    cleanup.Token);
+                if (current?.DownloadCancellationId is not { } durableCancellationId ||
+                    (current.IsDownloadTracked
+                        ? current.DownloadAttemptId != downloadAttemptId
+                        : current.IsDownloadFinished || current.DownloadAttemptId is not null))
+                    return current is null || !current.IsDownloadTracked
+                        ? DownloadCompensationOutcome.LocalStateRestored
+                        : DownloadCompensationOutcome.RetainedForRecovery;
+
+                cancellationAttemptId = durableCancellationId;
+                cancellationLease = await animationInfoRepository.TryBeginCancelDownloadAsync(
+                        info.Id,
+                        downloadAttemptId,
+                        cancellationAttemptId,
+                        Guid.NewGuid(),
+                        DownloadCancellationLeaseDuration,
+                        removeFile: false,
+                        requireUnfinished: true,
+                        SubscriptionAutomationDisposition.AutoDownloadFailed,
+                        cleanup.Token);
+                if (cancellationLease is null)
+                    return DownloadCompensationOutcome.RetainedForRecovery;
+            }
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(
+                exception,
+                "Could not register compensation for release upgrade download {AnimationInfoId}",
+                info.Id);
+            return DownloadCompensationOutcome.RetainedForRecovery;
+        }
+
+        if (remoteMayHaveAccepted && downloadClient is not null)
+        {
+            try
+            {
+                cleanup.Token.ThrowIfCancellationRequested();
+                var cancellation = await downloadClient.CancelDownloadTaskAsync(
+                    info.Id,
+                    info.DownloadUrl,
+                    info.CachedDownloadData,
+                    info.AdditionalDownloadInfo,
+                    cancellationLease.RemoveFile,
+                    cleanup.Token);
+                if (!cancellation.IsSuccess)
+                {
+                    await QueryDownloadProgressSafelyAsync(downloadClient, info, cleanup.Token);
+                    return DownloadCompensationOutcome.RetainedForRecovery;
+                }
+            }
+            catch (Exception exception)
+            {
+                logger.LogWarning(
+                    exception,
+                    "Could not confirm compensation for release upgrade download {AnimationInfoId}",
+                    info.Id);
+                await QueryDownloadProgressSafelyAsync(downloadClient, info, cleanup.Token);
+                return DownloadCompensationOutcome.RetainedForRecovery;
+            }
+        }
+        else if (remoteMayHaveAccepted)
+        {
+            return DownloadCompensationOutcome.RetainedForRecovery;
+        }
+
+        try
+        {
+            cleanup.Token.ThrowIfCancellationRequested();
+            var restored = await fileMappingRepository.TryFinalizeDownloadCancellationAsync(
+                info.Id,
+                downloadAttemptId,
+                cancellationAttemptId,
+                cancellationLease.Id,
+                terminalDisposition: null,
+                cleanup.Token);
+            if (restored)
+                return DownloadCompensationOutcome.LocalStateRestored;
+
+            var current = await animationInfoRepository.FindByIdAsync(info.Id, cleanup.Token);
+            return current is null || !current.IsDownloadTracked
+                ? DownloadCompensationOutcome.LocalStateRestored
+                : DownloadCompensationOutcome.RetainedForRecovery;
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(
+                exception,
+                "Could not restore local download state for release upgrade {AnimationInfoId}",
+                info.Id);
+            return DownloadCompensationOutcome.RetainedForRecovery;
+        }
+    }
+
+    private static async Task QueryDownloadProgressSafelyAsync(
+        IFileDownloadClient downloadClient,
+        AnimationInfo info,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await downloadClient.SubmitQueryDownloadProgressAsync(
+                info.Id,
+                info.DownloadUrl,
+                info.CachedDownloadData,
+                info.AdditionalDownloadInfo,
+                cancellationToken);
+        }
+        catch
+        {
+            // Startup recovery can rediscover the persisted attempt.
+        }
+    }
+
+    private static CancellationTokenSource? CreateLeaseBoundTokenSource(
+        CancellationToken cancellationToken,
+        long leaseRequestStartedAt,
+        TimeSpan leaseDuration)
+    {
+        var remaining = leaseDuration -
+                        Stopwatch.GetElapsedTime(leaseRequestStartedAt) -
+                        DownloadLeaseSafetyMargin;
+        if (remaining <= TimeSpan.Zero)
+            return null;
+        var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        tokenSource.CancelAfter(
+            remaining < TimeSpan.FromSeconds(10) ? remaining : TimeSpan.FromSeconds(10));
+        return tokenSource;
+    }
+
+    private static string UpgradeSource(Guid operationId) => $"release-upgrade:{operationId:N}";
+
+    private enum DownloadCompensationOutcome
+    {
+        LocalStateRestored,
+        RetainedForRecovery
+    }
+
+    private static ReleaseUpgradeExecutionResult Result(
+        bool success,
+        string outcome,
+        bool dryRun,
+        bool requiresDownload,
+        ReleaseUpgradeOperation? operation,
+        IReadOnlyList<string> errors) =>
+        new(success, outcome, dryRun, requiresDownload, operation, errors);
+}