Make album cover pictures mandatory, unify cover handling with playlists

Albums previously had no cover concept at all: no picture upload
flow, no GET /albums/{id}/cover, and AlbumApplicationResponse's
image-key fields were plumbed but never populated. Description,
Pictures and TrackCount already lived on the shared Album base entity
for both local and external albums, so unifying the cover story only
required building the missing local-album picture pipeline.

Backend, cloning PlayList's existing async picture-processing
architecture exactly (MassTransit routing slip + saga), but making
the picture mandatory instead of optional (matching Track's pattern):

- AlbumPictures moves from all-nullable to required fields.
- New AlbumConfiguration (routes/sizes), deliberately without
  PlayList's preset-picture fallback since a picture is now required
  up front.
- CreateAlbum now takes a mandatory PictureIntentId, validates and
  consumes the upload intent, and kicks off the same
  copy-to-final -> resize -> upload -> update-entity routing slip
  PlayLists use, via a new AlbumProcessingState saga that marks the
  album Failed on a picture-processing failure.
- UpdateAlbum takes an optional NewPictureIntentId to replace the
  cover later.
- New GET /albums/{id}/cover and POST /albums/upload-picture
  endpoints, mirroring the playlist ones.
- New EF migration for the AlbumProcessingState saga table.

Frontend:

- AlbumForm gains a cover dropzone, required on create and optional
  on edit (via ImageDropzone's new `required` prop), uploaded through
  the same presigned-upload helper playlists use.
- New /api/albums/{id}/cover proxy route.
- PlaylistArt gains a generic coverUrl prop so AlbumHeader and the
  album list/detail cards render the real uploaded cover instead of
  only the track mosaic fallback.

Delete-time picture cleanup for albums is intentionally left as a
follow-up, matching the existing gap in playlist deletion.

backend/Core/Musify.Infrastructure/MassTransit/Activities/Albums/MarkAlbumAsFailedActivity.cs

@@ -0,0 +1,32 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Albums
+{
+    internal class MarkAlbumAsFailedActivity(
+        IDatabase database,
+        ILogger<MarkAlbumAsFailedActivity> logger)
+        : IExecuteActivity<MarkAlbumAsFailedArguments>
+    {
+        public const string ExecuteEndpointName = "mark-album-as-failed";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<MarkAlbumAsFailedArguments> executeContext)
+        {
+            var album = await database.Albums
+                .SingleOrDefaultAsync(a => a.Id == executeContext.Arguments.AlbumId, executeContext.CancellationToken);
+
+            if (album is not null)
+            {
+                album.LifeCycleStatus = LifeCycleStatus.Failed;
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+                logger.LogInformation("Marked album {AlbumId} as failed", executeContext.Arguments.AlbumId);
+            }
+
+            return executeContext.Completed();
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Albums/PublishAlbumPictureProcessingEventActivity.cs

@@ -0,0 +1,34 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Albums
+{
+    internal class PublishAlbumPictureProcessingEventActivity(
+        IPublishEndpoint publishEndpoint,
+        ILogger<PublishAlbumPictureProcessingEventActivity> logger)
+        : IExecuteActivity<PublishAlbumPictureProcessingEventArguments>
+    {
+        public const string ExecuteEndpointName = "publish-album-picture-processing-event";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<PublishAlbumPictureProcessingEventArguments> executeContext)
+        {
+            var arguments = executeContext.Arguments;
+
+            await publishEndpoint.Publish(
+                new UpdateAlbumPictureEvent(
+                    arguments.AlbumId,
+                    arguments.Bucket,
+                    arguments.FinalPictureKey,
+                    arguments.Small,
+                    arguments.Medium,
+                    arguments.Large),
+                executeContext.CancellationToken);
+
+            logger.LogInformation("Published picture processing event for album {AlbumId}", arguments.AlbumId);
+
+            return executeContext.Completed();
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdateAlbumPictureActivity.cs

@@ -0,0 +1,113 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Pictures
+{
+    internal class UpdateAlbumPictureActivity(
+        IDatabase database,
+        IPublishEndpoint publishEndpoint,
+        ILogger<UpdateAlbumPictureActivity> logger)
+        : IActivity<UpdateAlbumPictureArguments, UpdateAlbumPictureLog>
+    {
+        public const string ExecuteEndpointName = "update-album-picture";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<UpdateAlbumPictureArguments> executeContext)
+        {
+            var smallResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.SmallPictureVariable);
+            ArgumentNullException.ThrowIfNull(smallResizedVariable, nameof(smallResizedVariable));
+            var mediumResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.MediumPictureVariable);
+            ArgumentNullException.ThrowIfNull(mediumResizedVariable, nameof(mediumResizedVariable));
+            var largeResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.LargePictureVariable);
+            ArgumentNullException.ThrowIfNull(largeResizedVariable, nameof(largeResizedVariable));
+
+            try
+            {
+                var album = await database.Albums.FindAsync(
+                    [executeContext.Arguments.AlbumId],
+                    cancellationToken: executeContext.CancellationToken);
+
+                if (album is null)
+                {
+                    logger.LogWarning("Album {AlbumId} not found",
+                        executeContext.Arguments.AlbumId);
+                    throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} not found");
+                }
+
+                if (album.Pictures is null)
+                {
+                    logger.LogWarning("Album {AlbumId} has no pending picture upload",
+                        executeContext.Arguments.AlbumId);
+                    throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} has no pending picture upload");
+                }
+
+                var log = new UpdateAlbumPictureLog(
+                    album.Id,
+                    album.Pictures.OriginalName,
+                    album.Pictures.SmallName,
+                    album.Pictures.MediumName,
+                    album.Pictures.LargeName);
+
+                album.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
+                album.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
+                album.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
+                album.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
+
+                database.Albums.Update(album);
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+
+                logger.LogInformation("Updated album {AlbumId} pictures",
+                    executeContext.Arguments.AlbumId);
+
+                await publishEndpoint.Publish(
+                    new AlbumPictureProcessed(executeContext.Arguments.AlbumId),
+                    executeContext.CancellationToken);
+
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to update album {AlbumId} pictures",
+                    executeContext.Arguments.AlbumId);
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UpdateAlbumPictureLog> compensateContext)
+        {
+            try
+            {
+                var album = await database.Albums.FindAsync(
+                    [compensateContext.Log.AlbumId],
+                    cancellationToken: compensateContext.CancellationToken);
+
+                if (album is null)
+                {
+                    return compensateContext.Compensated();
+                }
+
+                album.Pictures = new AlbumPictures
+                {
+                    OriginalName = compensateContext.Log.PreviousOriginalPictureKey,
+                    SmallName = compensateContext.Log.PreviousSmallPictureKey,
+                    MediumName = compensateContext.Log.PreviousMediumPictureKey,
+                    LargeName = compensateContext.Log.PreviousLargePictureKey
+                };
+
+                database.Albums.Update(album);
+                await database.SaveChangesAsync(compensateContext.CancellationToken);
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate album {AlbumId} pictures", compensateContext.Log.AlbumId);
+                return compensateContext.Failed(exception);
+            }
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Arguments/MarkAlbumAsFailedArguments.cs

@@ -0,0 +1,4 @@
+namespace Musify.Infrastructure.MassTransit.Arguments
+{
+    public record MarkAlbumAsFailedArguments(Guid AlbumId);
+}

backend/Core/Musify.Infrastructure/MassTransit/Arguments/PublishAlbumPictureProcessingEventArguments.cs

@@ -0,0 +1,12 @@
+using Musify.Application.Shared;
+
+namespace Musify.Infrastructure.MassTransit.Arguments
+{
+    public record PublishAlbumPictureProcessingEventArguments(
+        Guid AlbumId,
+        string Bucket,
+        string FinalPictureKey,
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
+}

backend/Core/Musify.Infrastructure/MassTransit/Arguments/UpdateAlbumPictureArguments.cs

@@ -0,0 +1,9 @@
+namespace Musify.Infrastructure.MassTransit.Arguments
+{
+    public record UpdateAlbumPictureArguments(
+        Guid AlbumId,
+        string OriginalPictureKey,
+        string SmallPictureVariable,
+        string MediumPictureVariable,
+        string LargePictureVariable);
+}

backend/Core/Musify.Infrastructure/MassTransit/Consumers/AlbumProcessingFailedConsumer.cs

@@ -0,0 +1,36 @@
+using MassTransit;
+using MassTransit.Courier.Contracts;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.Activities.Albums;
+using Musify.Infrastructure.MassTransit.Activities.Files;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.RoutingSlip;
+
+namespace Musify.Infrastructure.MassTransit.Consumers
+{
+    public class AlbumProcessingFailedConsumer(IBus bus) : IConsumer<AlbumProcessingFailed>
+    {
+        public async Task Consume(ConsumeContext<AlbumProcessingFailed> context)
+        {
+            var message = context.Message;
+
+            var builder = new RoutingSlipBuilder(NewId.NextGuid());
+            builder.AddSubscription(
+                EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
+                RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
+
+            if (!string.IsNullOrWhiteSpace(message.Bucket) && !string.IsNullOrWhiteSpace(message.PictureKey))
+                builder.AddActivity(
+                    ActivityNames.RemoveAlbumOriginalPicture,
+                    EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                    new RemoveFileFromBucketArguments(message.Bucket, message.PictureKey));
+
+            builder.AddActivity(
+                ActivityNames.MarkAlbumAsFailed,
+                EndpointHelper.BuildExecuteActivityUri(MarkAlbumAsFailedActivity.ExecuteEndpointName),
+                new MarkAlbumAsFailedArguments(message.AlbumId));
+
+            await bus.Execute(builder.Build());
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Consumers/CreateAlbumConsumer.cs

@@ -0,0 +1,22 @@
+using MassTransit;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
+
+namespace Musify.Infrastructure.MassTransit.Consumers
+{
+    public class CreateAlbumConsumer(
+        IBus bus,
+        AlbumPictureSourceRoutingSlipBuilder routingSlipBuilder)
+        : IConsumer<CreateAlbumResourcesEvent>
+    {
+
+        public async Task Consume(ConsumeContext<CreateAlbumResourcesEvent> consumeContext)
+        {
+            var routingSlip = routingSlipBuilder
+                .Build(consumeContext.Message, consumeContext.CorrelationId)
+                .Build();
+
+            await bus.Execute(routingSlip);
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Consumers/UpdateAlbumPictureConsumer.cs

@@ -0,0 +1,22 @@
+using MassTransit;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
+
+namespace Musify.Infrastructure.MassTransit.Consumers
+{
+    public class UpdateAlbumPictureConsumer(
+        IBus bus,
+        PictureWorkflowRoutingSlipBuilder routingSlipBuilder)
+        : IConsumer<UpdateAlbumPictureEvent>
+    {
+
+        public async Task Consume(ConsumeContext<UpdateAlbumPictureEvent> consumeContext)
+        {
+            var routingSlip = routingSlipBuilder
+                .Build(consumeContext.Message, consumeContext.CorrelationId)
+                .Build();
+
+            await bus.Execute(routingSlip);
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Consumers/UpdateAlbumPictureSourceConsumer.cs

@@ -0,0 +1,22 @@
+using MassTransit;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
+
+namespace Musify.Infrastructure.MassTransit.Consumers
+{
+    public class UpdateAlbumPictureSourceConsumer(
+        IBus bus,
+        AlbumPictureSourceRoutingSlipBuilder routingSlipBuilder)
+        : IConsumer<UpdateAlbumPictureSourceEvent>
+    {
+
+        public async Task Consume(ConsumeContext<UpdateAlbumPictureSourceEvent> consumeContext)
+        {
+            var routingSlip = routingSlipBuilder
+                .Build(consumeContext.Message, consumeContext.CorrelationId)
+                .Build();
+
+            await bus.Execute(routingSlip);
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/DependencyInjection/MassTransitDependencyInjection.Registration.cs

@@ -1,6 +1,7 @@
 using MassTransit;
 using Microsoft.Extensions.DependencyInjection;
 using Musify.Infrastructure.MassTransit.Activities.Pictures;
+using Musify.Infrastructure.MassTransit.Activities.Albums;
 using Musify.Infrastructure.MassTransit.Activities.Audio;
 using Musify.Infrastructure.MassTransit.Activities.Files;
 using Musify.Infrastructure.MassTransit.Activities.PlayLists;
@@ -23,6 +24,7 @@ namespace Musify.Infrastructure.MassTransit
             services.AddScoped<DeletePlayListRoutingSlipBuilder>();
             services.AddScoped<CreateTrackRoutingSlipBuilder>();
             services.AddScoped<PlayListPictureSourceRoutingSlipBuilder>();
+            services.AddScoped<AlbumPictureSourceRoutingSlipBuilder>();
             services.AddScoped<YouTubeTrackRoutingSlipBuilder>();
         }
 
@@ -41,6 +43,10 @@ namespace Musify.Infrastructure.MassTransit
             options.AddConsumer<TrackProcessingFailedConsumer>();
             options.AddConsumer<PlayListProcessingFailedConsumer>();
             options.AddConsumer<DownloadYouTubeTrackConsumer>();
+            options.AddConsumer<CreateAlbumConsumer>();
+            options.AddConsumer<UpdateAlbumPictureSourceConsumer>();
+            options.AddConsumer<UpdateAlbumPictureConsumer>();
+            options.AddConsumer<AlbumProcessingFailedConsumer>();
 
             options.AddExecuteActivity<RemoveFileFromBucketActivity, RemoveFileFromBucketArguments>();
             options.AddExecuteActivity<GenerateAudioWorkflowPathsActivity, GenerateAudioWorkflowPathsArguments>();
@@ -53,9 +59,12 @@ namespace Musify.Infrastructure.MassTransit
             options.AddExecuteActivity<PublishPlayListPictureProcessingEventActivity, PublishPlayListPictureProcessingEventArguments>();
             options.AddExecuteActivity<MarkTrackAsFailedActivity, MarkTrackAsFailedArguments>();
             options.AddExecuteActivity<MarkPlayListAsFailedActivity, MarkPlayListAsFailedArguments>();
+            options.AddExecuteActivity<MarkAlbumAsFailedActivity, MarkAlbumAsFailedArguments>();
+            options.AddExecuteActivity<PublishAlbumPictureProcessingEventActivity, PublishAlbumPictureProcessingEventArguments>();
 
             options.AddActivity<ResizePictureActivity, ResizePictureLocalArguments, ResizePictureLog>();
             options.AddActivity<UpdatePlayListPictureActivity, UpdatePlayListPictureArguments, UpdatePlayListPictureLog>();
+            options.AddActivity<UpdateAlbumPictureActivity, UpdateAlbumPictureArguments, UpdateAlbumPictureLog>();
             options.AddActivity<UpdateTrackPictureActivity, UpdateTrackPictureArguments, UpdateTrackPictureLog>();
             options.AddActivity<DownloadFileFromBucketActivity, DownloadFileFromBucketArguments, DownloadFileFromBucketLog>();
             options.AddActivity<TranscodeAudioActivity, TranscodeAudioArguments, TranscodeAudioLog>();

backend/Core/Musify.Infrastructure/MassTransit/DependencyInjection/MassTransitDependencyInjection.cs

@@ -83,6 +83,14 @@ namespace Musify.Infrastructure.MassTransit
                         repository.UsePostgres();
                     } );
 
+                options.AddSagaStateMachine<AlbumProcessingStateMachine, AlbumProcessingState>()
+                    .EntityFrameworkRepository(repository =>
+                    {
+                        repository.ConcurrencyMode = ConcurrencyMode.Pessimistic;
+                        repository.ExistingDbContext<Database>();
+                        repository.UsePostgres();
+                    } );
+
                 options.AddConfigureEndpointsCallback((registrationContext, _, endpointConfigurator) =>
                 {
                     UseStandardRetry(endpointConfigurator);

backend/Core/Musify.Infrastructure/MassTransit/Logs/UpdateAlbumPictureLog.cs

@@ -0,0 +1,9 @@
+namespace Musify.Infrastructure.MassTransit.Logs
+{
+    public record UpdateAlbumPictureLog(
+        Guid AlbumId,
+        string PreviousOriginalPictureKey,
+        string PreviousSmallPictureKey,
+        string PreviousMediumPictureKey,
+        string PreviousLargePictureKey);
+}

backend/Core/Musify.Infrastructure/MassTransit/RoutingSlip/ActivityNames.cs

@@ -8,6 +8,7 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip
         internal const string MarkPlayListAsRemoving = "MarkPlayListAsRemoving";
         internal const string MarkPlayListAsFailed = "MarkPlayListAsFailed";
         internal const string DeletePlayListFromDb = "DeletePlayListFromDb";
+        internal const string MarkAlbumAsFailed = "MarkAlbumAsFailed";
 
         internal const string GenerateAudioWorkflowPaths = "GenerateAudioWorkflowPaths";
         internal const string GeneratePictureWorkflowPaths = "GeneratePictureWorkflowPaths";
@@ -30,6 +31,7 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip
 
         internal const string UpdateTrackPicture = "UpdateTrackPicture";
         internal const string UpdatePlayListPicture = "UpdatePlayListPicture";
+        internal const string UpdateAlbumPicture = "UpdateAlbumPicture";
         internal const string UpdateTrackAudio = "UpdateTrackAudio";
 
         internal const string CopyPictureToFinal = "CopyPictureToFinal";
@@ -39,6 +41,7 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip
 
         internal const string PublishTrackProcessingEvents = "PublishTrackProcessingEvents";
         internal const string PublishPlayListPictureProcessingEvent = "PublishPlayListPictureProcessingEvent";
+        internal const string PublishAlbumPictureProcessingEvent = "PublishAlbumPictureProcessingEvent";
 
         internal const string RemoveTrackOriginalPicture = "RemoveTrackOriginalPicture";
         internal const string RemoveTrackSmallPicture = "RemoveTrackSmallPicture";
@@ -51,5 +54,7 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip
         internal const string RemovePlayListSmallPicture = "RemovePlayListSmallPicture";
         internal const string RemovePlayListMediumPicture = "RemovePlayListMediumPicture";
         internal const string RemovePlayListLargePicture = "RemovePlayListLargePicture";
+
+        internal const string RemoveAlbumOriginalPicture = "RemoveAlbumOriginalPicture";
     }
 }

backend/Core/Musify.Infrastructure/MassTransit/RoutingSlip/Builders/AlbumPictureSourceRoutingSlipBuilder.cs

@@ -0,0 +1,85 @@
+using MassTransit;
+using MassTransit.Courier.Contracts;
+using Musify.Application.Shared;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.Activities.Albums;
+using Musify.Infrastructure.MassTransit.Activities.Files;
+using Musify.Infrastructure.MassTransit.Activities.UploadIntents;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Consumers;
+
+namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
+{
+    public class AlbumPictureSourceRoutingSlipBuilder
+    {
+        public RoutingSlipBuilder Build(CreateAlbumResourcesEvent message, Guid? correlationId)
+            => BuildSlip(
+                message.AlbumId,
+                message.PictureIntentId,
+                message.Bucket,
+                message.PictureSourceKey,
+                message.PictureDestinationKey,
+                message.Small,
+                message.Medium,
+                message.Large,
+                correlationId);
+
+        public RoutingSlipBuilder Build(UpdateAlbumPictureSourceEvent message, Guid? correlationId)
+            => BuildSlip(
+                message.AlbumId,
+                message.PictureIntentId,
+                message.Bucket,
+                message.PictureSourceKey,
+                message.PictureDestinationKey,
+                message.Small,
+                message.Medium,
+                message.Large,
+                correlationId);
+
+        static RoutingSlipBuilder BuildSlip(
+            Guid albumId,
+            Guid pictureIntentId,
+            string bucket,
+            string pictureSourceKey,
+            string pictureDestinationKey,
+            ImageSize small,
+            ImageSize medium,
+            ImageSize large,
+            Guid? correlationId)
+        {
+            var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
+            routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.CorrelationId, correlationId ?? Guid.Empty);
+
+            routingSlipBuilder.AddSubscription(
+                EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
+                RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.CopyPictureToFinal,
+                EndpointHelper.BuildExecuteActivityUri(CopyFileInBucketActivity.ExecuteEndpointName),
+                new CopyFileInBucketArguments(
+                    bucket,
+                    pictureSourceKey,
+                    bucket,
+                    pictureDestinationKey));
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.ConsumeUploadIntents,
+                EndpointHelper.BuildExecuteActivityUri(ConsumeUploadIntentsActivity.ExecuteEndpointName),
+                new ConsumeUploadIntentsArguments([pictureIntentId]));
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.PublishAlbumPictureProcessingEvent,
+                EndpointHelper.BuildExecuteActivityUri(PublishAlbumPictureProcessingEventActivity.ExecuteEndpointName),
+                new PublishAlbumPictureProcessingEventArguments(
+                    albumId,
+                    bucket,
+                    pictureDestinationKey,
+                    small,
+                    medium,
+                    large));
+
+            return routingSlipBuilder;
+        }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/RoutingSlip/Builders/PictureWorkflowRoutingSlipBuilder.cs

@@ -70,6 +70,35 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
             return routingSlipBuilder;
         }
 
+        public RoutingSlipBuilder Build(UpdateAlbumPictureEvent message, Guid? correlationId)
+        {
+            var routingSlipBuilder = BuildPictureWorkflow(
+                message.Bucket,
+                message.SourceKey,
+                message.Small,
+                message.Medium,
+                message.Large,
+                correlationId);
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.UpdateAlbumPicture,
+                EndpointHelper.BuildExecuteActivityUri(UpdateAlbumPictureActivity.ExecuteEndpointName),
+                new UpdateAlbumPictureArguments(
+                    message.AlbumId,
+                    message.SourceKey,
+                    RoutingSlipVariableNames.Picture.SmallResizedFilePath,
+                    RoutingSlipVariableNames.Picture.MediumResizedFilePath,
+                    RoutingSlipVariableNames.Picture.LargeResizedFilePath));
+
+            routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.SubjectId, message.AlbumId);
+            routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.ProcessKind, RoutingSlipVariableNames.ProcessKinds.AlbumPicture);
+            routingSlipBuilder.AddSubscription(
+                EndpointHelper.BuildConsumerUri(ProcessingSlipFaultConsumer.QueueName),
+                RoutingSlipEvents.Faulted);
+
+            return routingSlipBuilder;
+        }
+
         RoutingSlipBuilder BuildPictureWorkflow(
             string bucket,
             string sourceKey,

backend/Core/Musify.Infrastructure/MassTransit/RoutingSlip/RoutingSlipVariableNames.cs

@@ -15,6 +15,7 @@ namespace Musify.Infrastructure.MassTransit
             internal const string TrackPicture = "TrackPicture";
             internal const string TrackAudio = "TrackAudio";
             internal const string PlayListPicture = "PlayListPicture";
+            internal const string AlbumPicture = "AlbumPicture";
         }
 
         internal static class Audio

backend/Core/Musify.Infrastructure/MassTransit/Sagas/AlbumProcessingState.cs

@@ -0,0 +1,19 @@
+using MassTransit;
+
+namespace Musify.Infrastructure.MassTransit.Sagas
+{
+    public class AlbumProcessingState : SagaStateMachineInstance
+    {
+        public Guid CorrelationId { get; set; }
+
+        public string CurrentState { get; set; } = null!;
+
+        public string? Bucket { get; set; }
+
+        public string? PictureKey { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public DateTime UpdatedAt { get; set; }
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Sagas/AlbumProcessingStateMachine.cs

@@ -0,0 +1,51 @@
+using MassTransit;
+using Musify.Application.Events;
+
+namespace Musify.Infrastructure.MassTransit.Sagas
+{
+    public sealed class AlbumProcessingStateMachine : MassTransitStateMachine<AlbumProcessingState>
+    {
+        public State Processing { get; private set; } = null!;
+        public State Failed { get; private set; } = null!;
+
+        public Event<CreateAlbumResourcesEvent> ProcessingStarted { get; private set; } = null!;
+        public Event<AlbumPictureProcessed> PictureProcessed { get; private set; } = null!;
+        public Event<AlbumPictureProcessingFailed> PictureFailed { get; private set; } = null!;
+
+        public AlbumProcessingStateMachine()
+        {
+            InstanceState(state => state.CurrentState);
+
+            Event(() => ProcessingStarted, config => config.CorrelateById(context => context.Message.AlbumId));
+            Event(() => PictureProcessed, config => config.CorrelateById(context => context.Message.AlbumId));
+            Event(() => PictureFailed, config => config.CorrelateById(context => context.Message.AlbumId));
+
+            Initially(
+                When(ProcessingStarted)
+                    .Then(context =>
+                    {
+                        context.Saga.CreatedAt = DateTime.UtcNow;
+                        context.Saga.UpdatedAt = DateTime.UtcNow;
+                        context.Saga.Bucket = context.Message.Bucket;
+                        context.Saga.PictureKey = context.Message.PictureDestinationKey;
+                    } )
+                    .TransitionTo(Processing));
+
+            During(Processing,
+                When(PictureProcessed).Finalize(),
+                When(PictureFailed)
+                    .Then(context => context.Saga.UpdatedAt = DateTime.UtcNow)
+                    .TransitionTo(Failed)
+                    .Publish(context => new AlbumProcessingFailed(
+                        context.Saga.CorrelationId,
+                        context.Saga.Bucket,
+                        context.Saga.PictureKey)));
+
+            During(Failed,
+                Ignore(PictureProcessed),
+                Ignore(PictureFailed));
+
+            SetCompletedWhenFinalized();
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/Database.cs

@@ -163,6 +163,11 @@ namespace Musify.Infrastructure.Persistence
             playListProcessing.HasKey(state => state.CorrelationId);
             playListProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();
             playListProcessing.Property(state => state.CurrentState).HasMaxLength(64);
+
+            var albumProcessing = modelBuilder.Entity<AlbumProcessingState>();
+            albumProcessing.HasKey(state => state.CorrelationId);
+            albumProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();
+            albumProcessing.Property(state => state.CurrentState).HasMaxLength(64);
         }
 
         public DbSet<User> Users => Set<User>();

backend/Core/Musify.Infrastructure/Persistence/Migrations/20260910125022_AddAlbumProcessingStateSaga.cs

@@ -0,0 +1,38 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAlbumProcessingStateSaga : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "AlbumProcessingState",
+                columns: table => new
+                {
+                    CorrelationId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CurrentState = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: false),
+                    Bucket = table.Column<string>(type: "text", nullable: true),
+                    PictureKey = table.Column<string>(type: "text", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AlbumProcessingState", x => x.CorrelationId);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AlbumProcessingState");
+        }
+    }
+}

backend/Core/Musify.Infrastructure/Persistence/Migrations/DatabaseModelSnapshot.cs

@@ -657,6 +657,33 @@ namespace Musify.Infrastructure.Persistence.Migrations
                     b.ToTable("UserHasTrack");
                 });
 
+            modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.AlbumProcessingState", b =>
+                {
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Bucket")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CurrentState")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("PictureKey")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("CorrelationId");
+
+                    b.ToTable("AlbumProcessingState");
+                });
+
             modelBuilder.Entity("Musify.Infrastructure.MassTransit.Sagas.PlayListProcessingState", b =>
                 {
                     b.Property<Guid>("CorrelationId")
@@ -804,21 +831,25 @@ namespace Musify.Infrastructure.Persistence.Migrations
                                 .HasColumnType("uuid");
 
                             b1.Property<string>("LargeName")
+                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("LargePictureName");
 
                             b1.Property<string>("MediumName")
+                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("MediumPictureName");
 
                             b1.Property<string>("OriginalName")
+                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("OriginalPictureName");
 
                             b1.Property<string>("SmallName")
+                                .IsRequired()
                                 .HasMaxLength(64)
                                 .HasColumnType("character varying(64)")
                                 .HasColumnName("SmallPictureName");