feat(infra): add Track processing saga (state machine, phase 1)

Introduce a MassTransit saga state machine that correlates by TrackId and
tracks the two parallel processing slips (picture + audio):
- TrackProcessingStateMachine + EF-persisted TrackProcessingState
  (pessimistic concurrency, EntityFrameworkRepository), migration added
- Starts on CreateTrackResourcesEvent; UpdateTrack{Picture,Audio}Activity now
  publish TrackPictureProcessed / TrackAudioProcessed on success; when both
  arrive the saga finalizes (Ready). Failure transitions to a Failed state
  (cleanup wired in the next phase)
- Add LifeCycleStatus.Failed and the four outcome events

Verified: booted the Worker against RabbitMQ + migrated Postgres in Docker;
the saga endpoint 'track-processing-state' is configured and the bus starts
clean.

Build: 0 warnings, 0 errors.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/Musify.Infrastructure/MassTransit/Activities/Audio/UpdateTrackAudioActivity.cs

@@ -2,6 +2,7 @@ using MassTransit;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
+using Musify.Application.Events;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Infrastructure.MassTransit.Arguments;
@@ -11,6 +12,7 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
 {
     internal class UpdateTrackAudioActivity(
         IDatabase database,
+        IPublishEndpoint publishEndpoint,
         ILogger<UpdateTrackAudioActivity> logger)
         : IActivity<UpdateTrackAudioArguments, UpdateTrackAudioLog>
     {
@@ -37,6 +39,9 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
             if (string.IsNullOrWhiteSpace(audioFolderKey))
             {
                 logger.LogWarning("Audio folder key is empty for track {TrackId}; skipping update", track.Id);
+                await publishEndpoint.Publish(
+                    new TrackAudioProcessed(executeContext.Arguments.TrackId),
+                    executeContext.CancellationToken);
                 return executeContext.Completed();
             }
 
@@ -52,6 +57,10 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
 
                 logger.LogInformation("Updated track {TrackId} audio", executeContext.Arguments.TrackId);
 
+                await publishEndpoint.Publish(
+                    new TrackAudioProcessed(executeContext.Arguments.TrackId),
+                    executeContext.CancellationToken);
+
                 return executeContext.Completed(log);
             }
             catch (Exception exception)

backend/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdateTrackPictureActivity.cs

@@ -1,6 +1,7 @@
 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;
@@ -9,6 +10,7 @@ namespace Musify.Infrastructure.MassTransit.Activities.Pictures
 {
     internal class UpdateTrackPictureActivity(
         IDatabase database,
+        IPublishEndpoint publishEndpoint,
         ILogger<UpdateTrackPictureActivity> logger)
         : IActivity<UpdateTrackPictureArguments, UpdateTrackPictureLog>
     {
@@ -55,6 +57,10 @@ namespace Musify.Infrastructure.MassTransit.Activities.Pictures
                 logger.LogInformation("Updated track {TrackId} pictures",
                     executeContext.Arguments.TrackId);
 
+                await publishEndpoint.Publish(
+                    new TrackPictureProcessed(executeContext.Arguments.TrackId),
+                    executeContext.CancellationToken);
+
                 return executeContext.Completed();
             }
             catch (Exception exception)

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

@@ -3,6 +3,7 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Musify.Application.Contracts;
 using Musify.Infrastructure.Configuration;
+using Musify.Infrastructure.MassTransit.Sagas;
 using Musify.Infrastructure.Persistence;
 
 namespace Musify.Infrastructure.MassTransit
@@ -66,6 +67,14 @@ namespace Musify.Infrastructure.MassTransit
 
                 RegisterConsumersAndActivities(options);
 
+                options.AddSagaStateMachine<TrackProcessingStateMachine, TrackProcessingState>()
+                    .EntityFrameworkRepository(repository =>
+                    {
+                        repository.ConcurrencyMode = ConcurrencyMode.Pessimistic;
+                        repository.ExistingDbContext<Database>();
+                        repository.UsePostgres();
+                    });
+
                 options.AddConfigureEndpointsCallback((registrationContext, _, endpointConfigurator) =>
                 {
                     UseStandardRetry(endpointConfigurator);

backend/Musify.Infrastructure/MassTransit/Sagas/TrackProcessingState.cs

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

backend/Musify.Infrastructure/MassTransit/Sagas/TrackProcessingStateMachine.cs

@@ -0,0 +1,67 @@
+using MassTransit;
+using Musify.Application.Events;
+
+namespace Musify.Infrastructure.MassTransit.Sagas
+{
+    public sealed class TrackProcessingStateMachine : MassTransitStateMachine<TrackProcessingState>
+    {
+        public State Processing { get; private set; } = null!;
+        public State Failed { get; private set; } = null!;
+
+        public Event<CreateTrackResourcesEvent> ProcessingStarted { get; private set; } = null!;
+        public Event<TrackPictureProcessed> PictureProcessed { get; private set; } = null!;
+        public Event<TrackAudioProcessed> AudioProcessed { get; private set; } = null!;
+        public Event<TrackPictureProcessingFailed> PictureFailed { get; private set; } = null!;
+        public Event<TrackAudioProcessingFailed> AudioFailed { get; private set; } = null!;
+
+        public TrackProcessingStateMachine()
+        {
+            InstanceState(state => state.CurrentState);
+
+            Event(() => ProcessingStarted, config => config.CorrelateById(context => context.Message.TrackId));
+            Event(() => PictureProcessed, config => config.CorrelateById(context => context.Message.TrackId));
+            Event(() => AudioProcessed, config => config.CorrelateById(context => context.Message.TrackId));
+            Event(() => PictureFailed, config => config.CorrelateById(context => context.Message.TrackId));
+            Event(() => AudioFailed, config => config.CorrelateById(context => context.Message.TrackId));
+
+            Initially(
+                When(ProcessingStarted)
+                    .Then(context =>
+                    {
+                        context.Saga.CreatedAt = DateTime.UtcNow;
+                        context.Saga.UpdatedAt = DateTime.UtcNow;
+                    })
+                    .TransitionTo(Processing));
+
+            During(Processing,
+                When(PictureProcessed)
+                    .Then(context =>
+                    {
+                        context.Saga.PictureProcessed = true;
+                        context.Saga.UpdatedAt = DateTime.UtcNow;
+                    })
+                    .If(context => context.Saga.AudioProcessed, binder => binder.Finalize()),
+                When(AudioProcessed)
+                    .Then(context =>
+                    {
+                        context.Saga.AudioProcessed = true;
+                        context.Saga.UpdatedAt = DateTime.UtcNow;
+                    })
+                    .If(context => context.Saga.PictureProcessed, binder => binder.Finalize()),
+                When(PictureFailed)
+                    .Then(context => context.Saga.UpdatedAt = DateTime.UtcNow)
+                    .TransitionTo(Failed),
+                When(AudioFailed)
+                    .Then(context => context.Saga.UpdatedAt = DateTime.UtcNow)
+                    .TransitionTo(Failed));
+
+            During(Failed,
+                Ignore(PictureProcessed),
+                Ignore(AudioProcessed),
+                Ignore(PictureFailed),
+                Ignore(AudioFailed));
+
+            SetCompletedWhenFinalized();
+        }
+    }
+}