Non forza enableEmbed in creazione live: YouTube lo rifiuta sul canale piattaforma.

Co-authored-by: Cursor <cursoragent@cursor.com>

.cursor/rules/stream-soft-limit-scaling.mdc

@@ -0,0 +1,22 @@
+---
+description: Scalare soft limit ingest/autoscaler man mano che crescono i clienti
+alwaysApply: true
+---
+
+# Soft limit stream / autoscaler
+
+Con la crescita del numero di clienti (e delle dirette concorrenti attese), **alzare i soft limit** prima di restare a corto di capacità.
+
+Config rilevante (prod, tipicamente `infra/.env` + `StreamNode`):
+
+| Parametro | Ruolo oggi (post load test 2026-08) |
+|-----------|--------------------------------------|
+| `STREAM_NODE_HOME_MAX_PUBLISHERS` | Soft home (es. 6) |
+| `STREAM_CLOUD_MAX_PUBLISHERS` | Soft per CPX (es. 4; cpx12 ha tenuto 8 in probe) |
+| `STREAM_AUTOSCALE_MAX_OVERFLOW` / max overflow nodes | Quanti CPX in parallelo (es. 3 → tetto cluster ≈ home + N×cloud) |
+| `STREAM_AUTOSCALE_SOFT_FREE_SLOTS` | Anticipo scale-out |
+| Piano `concurrent_streams_limit` | Tetto **per club** (Premium Full = 10): indipendente dal cluster |
+
+Capienza cluster soft ≈ `home_max + max_overflow × cloud_max` (es. 6+3×4 = **18**).
+
+Quando si parla di capacity planning, deploy autoscale, o “troppe dirette”, ricordare di rivedere questi valori (e il limite piano) in base ai clienti reali — non lasciare i soft limit di collaudo/early-prod a lungo.

backend/app/controllers/admin/analytics_controller.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Admin
+  class AnalyticsController < Admin::BaseController
+    def index
+      @filters = {
+        from: parse_date(params[:from]) || 7.days.ago.to_date,
+        to: parse_date(params[:to]) || Time.zone.today,
+        device: params[:device].presence
+      }
+
+      scope = AnalyticsPageStat.where(day: @filters[:from]..@filters[:to])
+      scope = scope.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+
+      cell_scope = AnalyticsPageCell.where(day: @filters[:from]..@filters[:to])
+      cell_scope = cell_scope.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+
+      clicks_by_path = cell_scope.group(:page_path).sum(:click_count)
+      moves_by_path = cell_scope.group(:page_path).sum(:move_count)
+      pageviews_by_path = scope.group(:page_path).sum(:pageview_count)
+      scroll_samples_by_path = scope.group(:page_path).sum(:scroll_samples)
+      scroll_sum_by_path = scope.group(:page_path).sum(:scroll_sum_pct)
+      max_scroll_by_path = scope.group(:page_path).maximum(:max_scroll_pct)
+
+      paths = (pageviews_by_path.keys + clicks_by_path.keys + moves_by_path.keys).uniq
+      @pages = paths.map do |path|
+        samples = scroll_samples_by_path[path].to_i
+        {
+          page_path: path,
+          pageviews: pageviews_by_path[path].to_i,
+          clicks: clicks_by_path[path].to_i,
+          moves: moves_by_path[path].to_i,
+          scroll_samples: samples,
+          scroll_sum: scroll_sum_by_path[path].to_i,
+          max_scroll: max_scroll_by_path[path].to_i
+        }
+      end.sort_by { |r| [-r[:pageviews], -r[:moves], -r[:clicks], r[:page_path]] }
+    end
+
+    def show
+      @page_path = params[:page_path].to_s
+      redirect_to admin_analytics_path, alert: t("admin.analytics.missing_path") and return if @page_path.blank?
+
+      @filters = {
+        from: parse_date(params[:from]) || 7.days.ago.to_date,
+        to: parse_date(params[:to]) || Time.zone.today,
+        device: params[:device].presence,
+        layer: params[:layer].to_s
+      }
+
+      cells = AnalyticsPageCell.where(page_path: @page_path, day: @filters[:from]..@filters[:to])
+      cells = cells.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+
+      @click_total = cells.sum(:click_count)
+      @move_total = cells.sum(:move_count)
+      @filters[:layer] =
+        if %w[move click].include?(@filters[:layer])
+          @filters[:layer]
+        elsif @move_total.positive?
+          "move"
+        else
+          "click"
+        end
+
+      counter = @filters[:layer] == "click" ? :click_count : :move_count
+      @cells = cells.group(:cell_x, :cell_y).sum(counter)
+      @max_weight = @cells.values.max.to_i
+      @total_points = @cells.values.sum
+
+      stats = AnalyticsPageStat.where(page_path: @page_path, day: @filters[:from]..@filters[:to])
+      stats = stats.where(device: @filters[:device]) if @filters[:device].present? && AnalyticsEvent::DEVICES.include?(@filters[:device])
+      @pageviews = stats.sum(:pageview_count)
+      @scroll_samples = stats.sum(:scroll_samples)
+      @scroll_sum = stats.sum(:scroll_sum_pct)
+      @max_scroll = stats.maximum(:max_scroll_pct).to_i
+      @avg_scroll = @scroll_samples.positive? ? (@scroll_sum.to_f / @scroll_samples).round : 0
+      @grid = AnalyticsPageCell::GRID_SIZE
+      @snapshot = find_snapshot(@page_path, @filters[:device])
+    end
+
+    private
+
+    def parse_date(value)
+      return nil if value.blank?
+
+      Date.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def find_snapshot(page_path, device)
+      scope = AnalyticsPageSnapshot.where(page_path: page_path)
+      if device.present? && AnalyticsEvent::DEVICES.include?(device)
+        snap = scope.find_by(device: device)
+        return snap if snap&.image&.attached?
+      end
+
+      scope.order(captured_at: :desc).detect { |s| s.image.attached? }
+    end
+  end
+end

backend/app/controllers/admin/announcements_controller.rb

@@ -0,0 +1,76 @@
+module Admin
+  class AnnouncementsController < Admin::BaseController
+    before_action :set_announcement, only: %i[edit update destroy]
+
+    def index
+      @announcements = AppAnnouncement.newest
+    end
+
+    def new
+      @announcement = AppAnnouncement.new(
+        kind: "info",
+        severity: "info",
+        status: "draft",
+        show_on_android: true,
+        show_on_ios: true,
+        show_on_web_public: true,
+        show_on_web_private: true,
+        dismissible: true
+      )
+    end
+
+    def create
+      @announcement = AppAnnouncement.new(announcement_params)
+      @announcement.created_by_admin = current_admin_account
+      if @announcement.save
+        redirect_to admin_announcements_path, notice: t("admin.flash.announcement_created")
+      else
+        flash.now[:alert] = @announcement.errors.full_messages.join(", ")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @announcement.update(announcement_params)
+        redirect_to admin_announcements_path, notice: t("admin.flash.announcement_updated")
+      else
+        flash.now[:alert] = @announcement.errors.full_messages.join(", ")
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @announcement.destroy!
+      redirect_to admin_announcements_path, notice: t("admin.flash.announcement_destroyed")
+    end
+
+    private
+
+    def set_announcement
+      @announcement = AppAnnouncement.find(params[:id])
+    end
+
+    def announcement_params
+      params.require(:app_announcement).permit(
+        :kind, :severity, :status, :title, :body,
+        :action_url, :action_label, :dismissible, :starts_at, :ends_at,
+        :show_on_android, :show_on_ios, :show_on_web_public, :show_on_web_private,
+        translations: {
+          en: AppAnnouncement::COPY_KEYS,
+          fr: AppAnnouncement::COPY_KEYS,
+          de: AppAnnouncement::COPY_KEYS,
+          es: AppAnnouncement::COPY_KEYS
+        }
+      ).tap do |permitted|
+        %i[dismissible show_on_android show_on_ios show_on_web_public show_on_web_private].each do |key|
+          permitted[key] = ActiveModel::Type::Boolean.new.cast(permitted[key])
+        end
+        %i[starts_at ends_at action_url action_label].each do |key|
+          permitted[key] = nil if permitted[key].blank?
+        end
+      end
+    end
+  end
+end

backend/app/controllers/admin/auth_controller.rb

@@ -1,6 +1,8 @@
 module Admin
   class AuthController < Admin::BaseController
     skip_before_action :require_admin_login, only: %i[new create]
+    # Same as public logout: tolerate stale CSRF after long-lived admin tabs.
+    skip_before_action :verify_authenticity_token, only: :destroy
 
     def new
       redirect_to admin_root_path if admin_logged_in?

backend/app/controllers/admin/dashboard_controller.rb

@@ -5,7 +5,7 @@ module Admin
       @host = HostMetrics.new.sample!
       @active_sessions = StreamSession
         .where(status: DashboardStats::ACTIVE_STATUSES)
-        .includes(match: :team)
+        .includes(:stream_node, match: :team)
         .order(started_at: :desc)
       @teams = Team.includes(:matches).order(:name).limit(8)
     end

backend/app/controllers/admin/sessions_controller.rb

@@ -1,12 +1,23 @@
 module Admin
   class SessionsController < Admin::BaseController
     def index
-      @sessions = StreamSession.includes(:match, :user).order(created_at: :desc).limit(50)
+      @filters = session_filters
+      scope = filtered_sessions
+      @total_count = scope.count
+      @sessions = scope
+        .includes(:stream_node, :user, match: { team: :club })
+        .order(Arel.sql("COALESCE(stream_sessions.started_at, stream_sessions.created_at) DESC"))
+        .limit(100)
+      @clubs = Club.order(:name)
+      @nodes = StreamNode.order(:slug)
     end
 
     def show
-      @session = StreamSession.find(params[:id])
+      @session = StreamSession
-      @events = @session.stream_events.recent.limit(50)
+        .includes(:stream_node, :user, :device_states, :recording, match: { team: :club })
+        .find(params[:id])
+      @events = @session.stream_events.recent.limit(100)
+      @club = @session.match.team.club
     end
 
     def stop
@@ -39,5 +50,73 @@ module Admin
                     regia_expires_at: @session.regia_token_expires_at&.iso8601
                   }
     end
+
+    private
+
+    def session_filters
+      {
+        q: params[:q].to_s.strip.presence,
+        status: params[:status].to_s.strip.presence,
+        platform: params[:platform].to_s.strip.presence,
+        club_id: params[:club_id].to_s.strip.presence,
+        stream_node_id: params[:stream_node_id].to_s.strip.presence,
+        from: params[:from].to_s.strip.presence,
+        to: params[:to].to_s.strip.presence
+      }
+    end
+
+    def filtered_sessions
+      scope = StreamSession.left_outer_joins(match: { team: :club })
+
+      if @filters[:q].present?
+        term = "%#{ActiveRecord::Base.sanitize_sql_like(@filters[:q])}%"
+        scope = scope.where(
+          "teams.name ILIKE :term OR matches.opponent_name ILIKE :term OR clubs.name ILIKE :term OR matches.location ILIKE :term",
+          term: term
+        )
+      end
+
+      if @filters[:status].present? && StreamSession::STATUSES.include?(@filters[:status])
+        scope = scope.where(stream_sessions: { status: @filters[:status] })
+      end
+      if @filters[:platform].present? && StreamSession::LIVE_PLATFORMS.include?(@filters[:platform])
+        scope = scope.where(stream_sessions: { platform: @filters[:platform] })
+      end
+      if @filters[:club_id].present?
+        scope = scope.where(teams: { club_id: @filters[:club_id] })
+      end
+      if @filters[:stream_node_id].present?
+        node = StreamNode.find_by(id: @filters[:stream_node_id])
+        if node
+          scope = scope.where(
+            "stream_sessions.stream_node_id = :id OR stream_sessions.ingest_slug = :slug",
+            id: node.id,
+            slug: node.slug
+          )
+        end
+      end
+      if (from_time = parse_filter_date(@filters[:from], end_of_day: false))
+        scope = scope.where(
+          "COALESCE(stream_sessions.started_at, stream_sessions.created_at) >= ?",
+          from_time
+        )
+      end
+      if (to_time = parse_filter_date(@filters[:to], end_of_day: true))
+        scope = scope.where(
+          "COALESCE(stream_sessions.started_at, stream_sessions.created_at) <= ?",
+          to_time
+        )
+      end
+      scope
+    end
+
+    def parse_filter_date(value, end_of_day:)
+      return nil if value.blank?
+
+      date = Date.parse(value)
+      end_of_day ? date.end_of_day : date.beginning_of_day
+    rescue ArgumentError, TypeError
+      nil
+    end
   end
 end

backend/app/controllers/analytics/events_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Analytics
+  class EventsController < ActionController::API
+    def create
+      payload = parse_payload
+      result = Analytics::Ingest.new(events: payload, remote_ip: request.remote_ip).call
+
+      if result.rate_limited
+        return head :too_many_requests
+      end
+
+      render json: { accepted: result.accepted, rejected: result.rejected }, status: :accepted
+    end
+
+    private
+
+    def parse_payload
+      body = request.request_parameters
+      return body["events"] if body.is_a?(Hash) && body["events"].is_a?(Array)
+      return body if body.is_a?(Array)
+
+      raw = request.raw_post
+      return [] if raw.blank?
+
+      parsed = JSON.parse(raw)
+      return parsed["events"] if parsed.is_a?(Hash) && parsed["events"].is_a?(Array)
+      return parsed if parsed.is_a?(Array)
+
+      []
+    rescue JSON::ParserError
+      []
+    end
+  end
+end

backend/app/controllers/analytics/snapshots_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Analytics
+  class SnapshotsController < ActionController::API
+    def create
+      result = Analytics::SnapshotIngest.new(
+        path: params[:path] || params[:page_path],
+        device: params[:device],
+        width: params[:width],
+        height: params[:height],
+        image: params[:image],
+        remote_ip: request.remote_ip
+      ).call
+
+      return head :too_many_requests if result.rate_limited
+      return render json: { ok: false, error: result.error }, status: :unprocessable_content unless result.ok
+
+      render json: { ok: true, skipped: result.skipped }, status: :accepted
+    end
+  end
+end

backend/app/controllers/api/v1/announcements_controller.rb

@@ -0,0 +1,13 @@
+module Api
+  module V1
+    class AnnouncementsController < BaseController
+      skip_before_action :authenticate_request!
+
+      def index
+        platform = params[:platform].to_s.presence
+        announcements = AppAnnouncement.for_platform(platform).newest
+        render json: announcements.map { |item| item.as_api_json(platform: platform) }
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/base_controller.rb

@@ -2,6 +2,8 @@ module Api
   module V1
     class BaseController < ApplicationController
       rescue_from Teams::EntitlementError, with: :render_entitlement_error
+      rescue_from Streams::IngestUnavailableError, with: :render_ingest_unavailable
+      rescue_from BrandingAttachments::CoverUploadError, with: :render_cover_upload_error
       rescue_from Youtube::BroadcastService::Error, with: :render_youtube_error
 
       private
@@ -20,6 +22,17 @@ module Api
           billing_url: error.billing_url
         }, status: :forbidden
       end
+
+      def render_ingest_unavailable(error)
+        render json: {
+          error: error.message,
+          error_code: error.code
+        }, status: :service_unavailable
+      end
+
+      def render_cover_upload_error(error)
+        render json: { error: error.message, error_code: "cover_upload_invalid" }, status: :unprocessable_entity
+      end
     end
   end
 end

backend/app/controllers/api/v1/matches_controller.rb

@@ -2,6 +2,7 @@ module Api
   module V1
     class MatchesController < BaseController
       include Api::UrlHelper
+      include Api::CoverJson
       include BrandingAttachments
 
       before_action :set_team, only: %i[index create]
@@ -21,6 +22,7 @@ module Api
         normalize_scoring_rules!(attrs)
         match = @team.matches.create!(attrs)
         attach_opponent_logo(match)
+        attach_match_cover(match)
         render json: match_json(match), status: :created
       end
 
@@ -34,6 +36,7 @@ module Api
         normalize_opponent_color!(attrs)
         @match.update!(attrs)
         attach_opponent_logo(@match)
+        attach_match_cover(@match)
         render json: match_json(@match)
       end
 
@@ -98,6 +101,11 @@ module Api
         match.opponent_logo_file.attach(file) if file.present?
       end
 
+      def attach_match_cover(match)
+        attach_cover_image(match, entitlements: match.team.entitlements)
+        enqueue_cover_slate_generation(match)
+      end
+
       def match_json(match, detail: false)
         active = active_session_for(match)
         team = match.team
@@ -123,6 +131,7 @@ module Api
           home_logo_url: api_absolute_url(team.effective_logo_url),
           opponent_primary_color: match.effective_opponent_primary_color,
           opponent_logo_url: api_absolute_url(match.opponent_logo_url),
+          **match_cover_json(match),
           active_session_id: active&.id,
           active_session_status: active&.status,
           stream_completed: match.stream_completed?,

backend/app/controllers/api/v1/recordings_controller.rb

@@ -97,10 +97,11 @@ module Api
           replay_url: recording.replay_url,
           playback_url: recording.playback_stream_url,
           thumbnail_url: recording.thumbnail_url,
-          download_enabled: ent.phone_download_enabled?,
+          download_enabled: ent.phone_download_enabled? && recording.storage_key.present?,
           youtube_video_id: recording.youtube_video_id,
           youtube_watch_url: recording.youtube_watch_url,
-          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled? && recording.storage_key.present? && recording.youtube_video_id.blank?,
+          replay_source: recording.replay_source,
           source_platform: recording.source_platform,
           source_platform_label: recording.source_platform_label,
           expires_at: recording.expires_at,

backend/app/controllers/api/v1/stream_sessions_controller.rb

@@ -77,6 +77,7 @@ module Api
           thermal_state: sanitized_thermal_state,
           last_seen_at: Time.current
         )
+        Sessions::ApplyClientInfo.call(@session, params[:client]) if params[:client].present?
         sync_publisher_when_streaming!(params[:fps].to_f)
         SessionChannel.broadcast_message(@session, state.as_cable_payload)
         head :no_content
@@ -180,7 +181,12 @@ module Api
       end
 
       def session_params
-        params.permit(:platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps, :youtube_channel)
+        params.permit(
+          :platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps, :youtube_channel,
+          client: %i[os client_os app_version app_build version build build_number
+                     device_manufacturer manufacturer device_model model
+                     os_version system_version carrier network_operator operator]
+        )
       end
 
       def score_sync_params

backend/app/controllers/api/v1/teams_controller.rb

@@ -137,7 +137,8 @@ module Api
           youtube_mode: ent.plan.youtube_mode,
           staff_role: current_user.staff_role_for(team),
           can_stream: current_user.can_stream_for?(team),
-          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?
+          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?,
+          custom_cover_enabled: ent.can_use_custom_cover?
         }
         if detail
           data[:members] = team.user_teams.includes(:user).where.not(role: "owner").map do |ut|
@@ -170,12 +171,13 @@ module Api
           replay_url: recording.replay_url,
           playback_url: recording.playback_stream_url,
           thumbnail_url: recording.thumbnail_url,
-          download_enabled: ent.phone_download_enabled?,
+          download_enabled: ent.phone_download_enabled? && recording.storage_key.present?,
           view_count: recording.view_count,
           views_label: recording.views_label,
           youtube_video_id: recording.youtube_video_id,
           youtube_watch_url: recording.youtube_watch_url,
-          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled? && recording.storage_key.present? && recording.youtube_video_id.blank?,
+          replay_source: recording.replay_source,
           source_platform: recording.source_platform,
           source_platform_label: recording.source_platform_label,
           expires_at: recording.expires_at,

backend/app/controllers/concerns/api/cover_json.rb

@@ -0,0 +1,16 @@
+module Api
+  module CoverJson
+    extend ActiveSupport::Concern
+
+    private
+
+    def match_cover_json(match)
+      resolver = Streams::CoverResolver.new(match)
+      {
+        effective_cover_url: api_absolute_url(resolver.effective_cover_url),
+        cover_source: resolver.cover_source,
+        custom_cover_enabled: match.team.entitlements.can_use_custom_cover?
+      }
+    end
+  end
+end

backend/app/controllers/concerns/branding_attachments.rb

@@ -8,6 +8,48 @@ module BrandingAttachments
     record.logo_file.attach(file) if file.present?
   end
 
+  def attach_cover_image(record, entitlements:)
+    remove_flag = params[:remove_cover].to_s == "1" || params.dig(:match, :remove_cover).to_s == "1"
+    if remove_flag
+      record.cover_image.purge if record.cover_image.attached?
+      record.cover_slate.purge if record.cover_slate.attached?
+      return
+    end
+
+    file = params.dig(:branding, :cover_image) || params[:cover_image]
+    return if file.blank?
+
+    entitlements.assert_can_upload_cover!
+    validate_cover_file!(file)
+    record.cover_slate.purge if record.cover_slate.attached?
+    record.cover_image.attach(file)
+  end
+
+  def validate_cover_file!(file)
+    allowed_types = Coverable::COVER_IMAGE_TYPES
+
+    # Rileva MIME dal contenuto (magic bytes) ignorando il declared_type del client.
+    io = file.respond_to?(:tempfile) ? file.tempfile : file
+    io.rewind if io.respond_to?(:rewind)
+    detected = Marcel::MimeType.for(io, name: file.respond_to?(:original_filename) ? file.original_filename : nil)
+    io.rewind if io.respond_to?(:rewind)
+
+    unless detected.in?(allowed_types)
+      raise CoverUploadError, I18n.t("coverable.errors.invalid_type")
+    end
+
+    byte_size = file.respond_to?(:size) ? file.size : File.size(file.path)
+    if byte_size > Coverable::MAX_COVER_BYTES
+      raise CoverUploadError, I18n.t("coverable.errors.too_large")
+    end
+  end
+
+  class CoverUploadError < StandardError; end
+
+  def enqueue_cover_slate_generation(record)
+    GenerateCoverSlateJob.enqueue_for(record) if record.cover_image.attached?
+  end
+
   def normalize_hex_color(value, fallback)
     v = value.to_s.strip
     v = "##{v}" if v.match?(/\A[0-9A-Fa-f]{6}\z/)

backend/app/controllers/public/clubs_controller.rb

@@ -64,17 +64,26 @@ module Public
 
     def edit
       require_club_owner!(@club)
+      @entitlements = @club.teams.first&.entitlements
     end
 
     def update
       require_club_owner!(@club)
+      @entitlements = @club.teams.first!.entitlements
       @club.assign_attributes(club_params)
       attach_branding_logo(@club)
+      attach_cover_image(@club, entitlements: @entitlements)
       @club.save!
+      enqueue_cover_slate_generation(@club)
       redirect_to public_club_path(@club), notice: t("flash.clubs.updated")
     rescue ActiveRecord::RecordInvalid => e
+      @entitlements = @club.teams.first&.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @entitlements = @club.teams.first&.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def billing

backend/app/controllers/public/contacts_controller.rb

@@ -0,0 +1,46 @@
+module Public
+  class ContactsController < WebBaseController
+    def show
+      @inquiry = empty_inquiry
+    end
+
+    def create
+      result = Contacts::SubmitInquiry.call(params: inquiry_params, ip: request.remote_ip)
+
+      if result.ok
+        redirect_to public_contatti_path, notice: t("flash.contacts.sent")
+        return
+      end
+
+      @inquiry = inquiry_params
+      flash.now[:alert] = t("flash.contacts.#{result.error}")
+      render :show, status: result.error == :throttled ? :too_many_requests : :unprocessable_entity
+    end
+
+    private
+
+    def inquiry_params
+      {
+        name: params[:name].to_s,
+        email: params[:email].to_s,
+        club_name: params[:club_name].to_s,
+        topic: params[:topic].to_s,
+        message: params[:message].to_s,
+        website: params[:website].to_s,
+        accept_privacy: params[:accept_privacy].to_s
+      }
+    end
+
+    def empty_inquiry
+      {
+        name: "",
+        email: "",
+        club_name: "",
+        topic: "commercial",
+        message: "",
+        website: "",
+        accept_privacy: ""
+      }
+    end
+  end
+end

backend/app/controllers/public/live_controller.rb

@@ -51,6 +51,7 @@ module Public
         @session.status.in?(%w[connecting live reconnecting paused])
       )
       @publisher_online = !@stream_closed && mediamtx_publisher_online?(@session)
+      @cover_poster_url = Streams::CoverResolver.new(@match).effective_cover_url
     end
 
     def status

backend/app/controllers/public/sessions_controller.rb

@@ -1,5 +1,9 @@
 module Public
   class SessionsController < WebBaseController
+    # Logout must succeed even with a stale CSRF token (old tab after deploy /
+    # session rotate). SameSite=Lax already blocks cross-site cookie POSTs.
+    skip_before_action :verify_authenticity_token, only: :destroy
+
     def new
       if logged_in? && current_user.primary_club
         redirect_to public_club_path(current_user.primary_club)

backend/app/controllers/public/site_base_controller.rb

@@ -9,6 +9,7 @@ module Public
 
     protect_from_forgery with: :exception
     before_action :set_site_locale
+    before_action :load_site_announcements
 
     private
 
@@ -40,5 +41,27 @@ module Public
     def logged_in?
       current_user.present?
     end
+
+    PRIVATE_WEB_CONTROLLERS = %w[
+      accounts clubs teams club_recordings club_billing
+      club_matches matches team_roster_members
+    ].freeze
+
+    def load_site_announcements
+      @site_announcements = if skip_site_announcements?
+        AppAnnouncement.none
+      else
+        channel = private_web_area? ? :web_private : :web_public
+        AppAnnouncement.for_channel(channel).newest
+      end
+    end
+
+    def skip_site_announcements?
+      controller_name == "regia"
+    end
+
+    def private_web_area?
+      PRIVATE_WEB_CONTROLLERS.include?(controller_name)
+    end
   end
 end

backend/app/controllers/public/sitemap_controller.rb

@@ -8,6 +8,7 @@ module Public
         { loc: "#{base}/prezzi", changefreq: "monthly", priority: "0.9" },
         { loc: "#{base}/pallavolo-giovanile", changefreq: "monthly", priority: "0.85" },
         { loc: "#{base}/faq", changefreq: "monthly", priority: "0.8" },
+        { loc: "#{base}/contatti", changefreq: "monthly", priority: "0.6" },
         { loc: "#{base}/live", changefreq: "hourly", priority: "0.85" },
         { loc: "#{base}/squadre", changefreq: "daily", priority: "0.85" },
         { loc: "#{base}/privacy", changefreq: "yearly", priority: "0.3" },

backend/app/controllers/public/teams_controller.rb

@@ -42,19 +42,28 @@ module Public
     def edit
       require_club_owner_for_team!(@team)
       @club = @team.club
+      @entitlements = @team.entitlements
     end
 
     def update
       require_club_owner_for_team!(@team)
       @team.assign_attributes(team_params)
       attach_branding_logo(@team)
+      attach_cover_image(@team, entitlements: @team.entitlements)
       attach_team_photo(@team)
       @team.save!
+      enqueue_cover_slate_generation(@team)
       redirect_to public_team_details_path(@team), notice: t("flash.teams.updated")
     rescue ActiveRecord::RecordInvalid => e
       @club = @team.club
+      @entitlements = @team.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @club = @team.club
+      @entitlements = @team.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def invite

backend/app/helpers/admin_helper.rb

@@ -30,6 +30,113 @@ module AdminHelper
     links
   end
 
+  def admin_session_ingest_badge_class(role_or_node)
+    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
+    case role.to_s
+    when "home" then "badge--ingest-home"
+    when "lab" then "badge--ingest-lab"
+    when "cloud" then "badge--ingest-cloud"
+    else "badge--paused"
+    end
+  end
+
+  def admin_session_ingest_role_label(role_or_node)
+    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
+    I18n.t("admin.sessions.ingest.role.#{role}", default: role.to_s.humanize)
+  end
+
+  def admin_session_status_badge_class(status)
+    case status.to_s
+    when "live" then "badge--live"
+    when "connecting", "reconnecting" then "badge--connecting"
+    when "paused", "idle" then "badge--paused"
+    when "ended" then "badge--ended"
+    when "error" then "badge--error"
+    else "badge--paused"
+    end
+  end
+
+  def admin_datetime(time, with_seconds: false)
+    return I18n.t("admin.common.dash") if time.blank?
+
+    format = with_seconds ? "%d/%m/%Y %H:%M:%S" : "%d/%m/%Y %H:%M"
+    time.in_time_zone.strftime(format)
+  end
+
+  def admin_session_duration_label(session)
+    secs = session.total_duration_secs.to_i
+    if secs <= 0 && session.started_at
+      end_time = session.ended_at || (session.terminal? ? session.updated_at : Time.current)
+      secs = (end_time - session.started_at).to_i if end_time
+    end
+    return I18n.t("admin.common.dash") if secs <= 0
+
+    hours = secs / 3600
+    mins = (secs % 3600) / 60
+    rem = secs % 60
+    if hours.positive?
+      format("%dh %02dm %02ds", hours, mins, rem)
+    elsif mins.positive?
+      format("%dm %02ds", mins, rem)
+    else
+      "#{rem}s"
+    end
+  end
+
+  def admin_session_client_os_label(session)
+    case session.client_os.to_s
+    when "android" then "Android"
+    when "ios" then "iOS"
+    else I18n.t("admin.common.dash")
+    end
+  end
+
+  def admin_session_client_summary(session)
+    parts = []
+    parts << admin_session_client_os_label(session) if session.client_os.present?
+    if session.app_version.present?
+      ver = session.app_version
+      ver = "#{ver} (#{session.app_build})" if session.app_build.present?
+      parts << "app #{ver}"
+    end
+    device = [session.device_manufacturer, session.device_model].compact_blank.join(" ")
+    parts << device if device.present?
+    parts << "OS #{session.os_version}" if session.os_version.present?
+    parts << session.carrier if session.carrier.present?
+    parts.presence&.join(" · ") || I18n.t("admin.common.dash")
+  end
+
+  def admin_format_event_meta(metadata)
+    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if metadata.blank?
+
+    pairs = metadata.to_h
+    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if pairs.empty?
+
+    content_tag(:dl, class: "admin-event-meta") do
+      safe_join(
+        pairs.map do |key, value|
+          content_tag(:div, class: "admin-event-meta__row") do
+            content_tag(:dt, key.to_s) +
+              content_tag(:dd, admin_event_meta_value(value))
+          end
+        end
+      )
+    end
+  end
+
+  def admin_event_meta_value(value)
+    case value
+    when Hash, Array
+      content_tag(:code, value.to_json)
+    when TrueClass, FalseClass
+      value ? "true" : "false"
+    when NilClass
+      I18n.t("admin.common.dash")
+    else
+      value.to_s
+    end
+  end
+
   def admin_regia_expires_label(iso_time)
     return if iso_time.blank?
 
@@ -37,4 +144,31 @@ module AdminHelper
   rescue ArgumentError, TypeError
     nil
   end
+
+  def announcement_status_badge(item)
+    case item.status
+    when "published" then item.severity == "critical" ? "live" : "ready"
+    when "archived" then "paused"
+    else "connecting"
+    end
+  end
+
+  def announcement_window_label(item)
+    start_label = item.starts_at&.in_time_zone&.strftime("%d/%m %H:%M")
+    end_label = item.ends_at&.in_time_zone&.strftime("%d/%m %H:%M")
+    if start_label && end_label
+      "#{start_label} → #{end_label}"
+    elsif start_label
+      I18n.t("admin.announcements.window.from", time: start_label)
+    elsif end_label
+      I18n.t("admin.announcements.window.until", time: end_label)
+    else
+      I18n.t("admin.announcements.window.always")
+    end
+  end
+
+  def announcement_channels_label(item)
+    labels = item.selected_channels.map { |key| I18n.t("admin.announcements.channels.#{key}") }
+    labels.presence&.join(" · ") || I18n.t("admin.common.dash")
+  end
 end

backend/app/helpers/legal_helper.rb

@@ -1,6 +1,6 @@
 module LegalHelper
   def legal_last_updated
-    "3 giugno 2026"
+    "20 agosto 2026"
   end
 
   def cookie_policy_last_updated

backend/app/helpers/public/regia_helper.rb

@@ -52,6 +52,18 @@ module Public
         muteError: t("regia.js.mute_error"),
         closeError: t("regia.js.close_error"),
         closeConfirm: t("regia.js.close_confirm"),
+        pauseConfirmTitle: t("regia.js.pause_confirm_title"),
+        pauseConfirmBody: t("regia.js.pause_confirm_body"),
+        resumeConfirmTitle: t("regia.js.resume_confirm_title"),
+        resumeConfirmBody: t("regia.js.resume_confirm_body"),
+        muteConfirmTitle: t("regia.js.mute_confirm_title"),
+        muteConfirmBody: t("regia.js.mute_confirm_body"),
+        unmuteConfirmTitle: t("regia.js.unmute_confirm_title"),
+        unmuteConfirmBody: t("regia.js.unmute_confirm_body"),
+        advancePeriodTitle: t("regia.js.advance_period_title"),
+        advancePeriodBody: t("regia.js.advance_period_body"),
+        confirmAction: t("regia.modal.confirm_action"),
+        stopConfirmTitle: t("regia.js.stop_confirm_title"),
         linkUnavailable: t("regia.js.link_unavailable"),
         linkCopied: t("regia.js.link_copied"),
         copyPrompt: t("regia.js.copy_prompt"),

backend/app/jobs/analytics/aggregate_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Analytics
+  class AggregateJob < ApplicationJob
+    queue_as :default
+
+    def perform(purge: false)
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      lock_key = "analytics:aggregate:lock"
+      acquired = redis.set(lock_key, "1", nx: true, ex: 120)
+      return unless acquired
+
+      begin
+        service = Analytics::Aggregate.new
+        service.call
+        service.purge_old! if purge
+      ensure
+        redis.del(lock_key)
+      end
+    rescue StandardError => e
+      Rails.logger.error("[analytics] aggregate failed: #{e.class} #{e.message}")
+      raise
+    end
+  end
+end

backend/app/jobs/generate_cover_slate_job.rb

@@ -0,0 +1,19 @@
+class GenerateCoverSlateJob < ApplicationJob
+  queue_as :default
+
+  def self.enqueue_for(record)
+    return unless record&.cover_image&.attached?
+
+    queue = record.is_a?(Match) ? :critical : :default
+    set(queue: queue).perform_later(record.class.name, record.id)
+  end
+
+  def perform(class_name, record_id)
+    record = class_name.constantize.find_by(id: record_id)
+    return unless record&.cover_image&.attached?
+
+    Streams::GenerateCoverSlate.call(record)
+  rescue Streams::GenerateCoverSlate::Error => e
+    Rails.logger.warn("[GenerateCoverSlateJob] #{class_name}##{record_id} #{e.message}")
+  end
+end

backend/app/jobs/recordings/clear_temporary_media_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Recordings
+  class ClearTemporaryMediaJob
+    include Sidekiq::Job
+    sidekiq_options retry: 3, queue: "default"
+
+    def perform(recording_id, reason = "verified")
+      recording = Recording.find_by(id: recording_id)
+      return unless recording
+
+      Recordings::ClearTemporaryMedia.new(
+        recording,
+        reason: reason.to_sym,
+        force: reason.to_s == "verified"
+      ).call
+    end
+  end
+end

backend/app/jobs/recordings/post_process_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Recordings
   class PostProcessJob
     include Sidekiq::Job
@@ -7,10 +9,30 @@ module Recordings
       recording = Recording.find_by(id: recording_id)
       return unless recording&.ready?
 
-      Recordings::NotifyReady.new(recording).call
+      begin
+        Recordings::NotifyReady.new(recording).call
+      rescue StandardError => e
+        # SMTP/ntfy giù non deve bloccare VerifyYoutubeReplay né il resto del post-process.
+        Rails.logger.warn(
+          "[Recordings::PostProcessJob] notify_failed recording=#{recording.id} " \
+          "#{e.class}: #{e.message}"
+        )
+      end
 
+      if recording.temporary_storage?
+        grace = MatchLiveTv.youtube_replay_verify_grace_secs
+        Rails.logger.info(
+          "[Recordings::PostProcessJob] schedule VerifyYoutubeReplay " \
+          "recording=#{recording.id} grace=#{grace}s"
+        )
+        Recordings::VerifyYoutubeReplayJob.perform_in(grace.seconds, recording.id, 0)
+        return
+      end
+
+      # Solo MatchLiveTV-only: eventuale re-upload manuale/flag legacy (non per live YouTube).
       return unless recording.auto_publish_youtube?
       return if recording.youtube_video_id.present?
+      return if recording.source_platform == "youtube"
 
       Recordings::PublishToYoutubeJob.perform_async(recording.id)
     end

backend/app/jobs/recordings/purge_temporary_media_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Recordings
+  # Safety net: elimina copie temp scadute (anche se verify non è mai riuscito).
+  class PurgeTemporaryMediaJob
+    include Sidekiq::Job
+    sidekiq_options retry: 1, queue: "default"
+
+    def perform
+      scope = Recording.temporary_media_pending_purge
+      count = 0
+
+      scope.find_each do |recording|
+        unless recording.youtube_verified_at.present?
+          Rails.logger.warn(
+            "[Recordings::PurgeTemporaryMediaJob] anomaly_unverified_expiry " \
+            "recording=#{recording.id} session=#{recording.stream_session_id} " \
+            "youtube_video_id=#{recording.youtube_video_id.inspect} " \
+            "temp_expires_at=#{recording.temp_expires_at.inspect}"
+          )
+        end
+
+        Recordings::ClearTemporaryMedia.new(
+          recording,
+          reason: :max_retention,
+          force: true
+        ).call
+        count += 1
+      end
+
+      Rails.logger.info("[Recordings::PurgeTemporaryMediaJob] processed=#{count}")
+      count
+    end
+  end
+end

backend/app/jobs/recordings/verify_youtube_replay_job.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Recordings
+  class VerifyYoutubeReplayJob
+    include Sidekiq::Job
+    sidekiq_options retry: 0, queue: "default"
+
+    def perform(recording_id, attempt = 0)
+      recording = Recording.find_by(id: recording_id)
+      return unless recording&.temporary_storage?
+      return if recording.deleted?
+
+      attempt = attempt.to_i
+      max = MatchLiveTv.youtube_replay_verify_max_attempts
+      result = Recordings::VerifyYoutubeReplay.new(recording).call
+
+      if result.ok?
+        recording.reload
+        embeddable = recording.metadata.is_a?(Hash) && recording.metadata.dig("youtube", "embeddable") != false
+        if embeddable
+          Recordings::ClearTemporaryMediaJob.perform_async(recording.id, "verified")
+        else
+          Rails.logger.warn(
+            "[Recordings::VerifyYoutubeReplayJob] keep_temp recording=#{recording.id} " \
+            "youtube_not_embeddable"
+          )
+        end
+        return
+      end
+
+      if result.retriable? && attempt + 1 < max
+        delay = backoff_secs(attempt)
+        Rails.logger.info(
+          "[Recordings::VerifyYoutubeReplayJob] retry recording=#{recording.id} " \
+          "attempt=#{attempt + 1}/#{max} in=#{delay}s msg=#{result.message}"
+        )
+        self.class.perform_in(delay.seconds, recording.id, attempt + 1)
+        return
+      end
+
+      Rails.logger.warn(
+        "[Recordings::VerifyYoutubeReplayJob] give_up recording=#{recording.id} " \
+        "attempts=#{attempt + 1} msg=#{result.message} " \
+        "temp_expires_at=#{recording.temp_expires_at.inspect}"
+      )
+    end
+
+    private
+
+    def backoff_secs(attempt)
+      base = MatchLiveTv.youtube_replay_verify_base_interval_secs
+      # 300, 600, 1200, ... capped at 1h
+      [base * (2**attempt), 3600].min
+    end
+  end
+end

backend/app/jobs/streams/autoscaler_job.rb

@@ -8,6 +8,8 @@ module Streams
 
     INTERVAL_SECS = ENV.fetch("STREAM_AUTOSCALE_INTERVAL_SECS", "60").to_i
     REDIS_CHAIN_KEY = "streams:autoscaler:chain"
+    KICK_DEBOUNCE_KEY = "streams:autoscaler:kick"
+    KICK_DEBOUNCE_SECS = ENV.fetch("STREAM_AUTOSCALE_KICK_DEBOUNCE_SECS", "5").to_i
 
     def self.ensure_chain
       return unless redis
@@ -17,6 +19,16 @@ module Streams
       perform_in(INTERVAL_SECS)
     end
 
+    # Kick immediato (es. NoCapacity / soft-free bassi). Debounce anti-flood Sidekiq.
+    def self.kick!
+      return false unless Streams::Autoscaler.enabled?
+      return false unless redis
+      return false unless redis.set(KICK_DEBOUNCE_KEY, "1", nx: true, ex: KICK_DEBOUNCE_SECS)
+
+      perform_async
+      true
+    end
+
     def self.redis
       @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
     rescue Redis::CannotConnectError

backend/app/mailers/contact_mailer.rb

@@ -0,0 +1,25 @@
+class ContactMailer < ApplicationMailer
+  def inquiry(name:, email:, club_name:, topic:, message:)
+    @name = name
+    @email = email
+    @club_name = club_name.presence
+    @topic = topic
+    @message = message
+
+    mail(
+      to: recipient_for(topic),
+      reply_to: email,
+      subject: t("mailers.contact.subject.#{topic}", name: name)
+    )
+  end
+
+  private
+
+  def recipient_for(topic)
+    if topic == "privacy"
+      MatchLiveTv.privacy_controller_email
+    else
+      MatchLiveTv.support_email
+    end
+  end
+end

backend/app/models/admin_account.rb

@@ -2,6 +2,7 @@ class AdminAccount < ApplicationRecord
   include PasswordComplexity
 
   has_secure_password
+  has_many :app_announcements, foreign_key: :created_by_admin_id, dependent: :nullify, inverse_of: :created_by_admin
 
   validates :username, presence: true, uniqueness: true
 end

backend/app/models/analytics_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AnalyticsEvent < ApplicationRecord
+  self.table_name = "analytics_events"
+
+  EVENT_TYPES = %w[click scroll pageview move].freeze
+  DEVICES = %w[mobile tablet desktop].freeze
+
+  validates :page_path, presence: true
+  validates :device, inclusion: { in: DEVICES }
+  validates :event_type, inclusion: { in: EVENT_TYPES }
+  validates :occurred_at, presence: true
+  validates :weight, numericality: { greater_than: 0, less_than_or_equal_to: 500 }
+end

backend/app/models/analytics_page_cell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AnalyticsPageCell < ApplicationRecord
+  self.table_name = "analytics_page_cells"
+
+  GRID_SIZE = 40
+
+  validates :day, :page_path, :device, :cell_x, :cell_y, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+  validates :cell_x, :cell_y, inclusion: { in: 0...(GRID_SIZE) }
+  validates :click_count, numericality: { greater_than_or_equal_to: 0 }
+  validates :move_count, numericality: { greater_than_or_equal_to: 0 }
+end

backend/app/models/analytics_page_snapshot.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AnalyticsPageSnapshot < ApplicationRecord
+  self.table_name = "analytics_page_snapshots"
+
+  has_one_attached :image
+
+  validates :page_path, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+  validates :width, :height, numericality: { greater_than: 0 }
+  validates :captured_at, presence: true
+end

backend/app/models/analytics_page_stat.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AnalyticsPageStat < ApplicationRecord
+  self.table_name = "analytics_page_stats"
+
+  validates :day, :page_path, :device, presence: true
+  validates :device, inclusion: { in: AnalyticsEvent::DEVICES }
+
+  def avg_scroll_pct
+    return 0 if scroll_samples.to_i <= 0
+
+    (scroll_sum_pct.to_f / scroll_samples).round
+  end
+end

backend/app/models/app_announcement.rb

@@ -0,0 +1,240 @@
+class AppAnnouncement < ApplicationRecord
+  KINDS = %w[info maintenance update].freeze
+  SEVERITIES = %w[info warning critical].freeze
+  STATUSES = %w[draft published archived].freeze
+  CHANNELS = {
+    android: :show_on_android,
+    ios: :show_on_ios,
+    web_public: :show_on_web_public,
+    web_private: :show_on_web_private
+  }.freeze
+  COPY_KEYS = %w[title body action_url action_label].freeze
+  URL_KEYS = %w[action_url].freeze
+  TITLE_KEYS = %w[title].freeze
+  BODY_KEYS = %w[body].freeze
+  LABEL_KEYS = %w[action_label].freeze
+  LOCALE_FALLBACKS = {
+    "it" => %w[it],
+    "en" => %w[en it],
+    "fr" => %w[fr en it],
+    "de" => %w[de en it],
+    "es" => %w[es en it]
+  }.freeze
+
+  belongs_to :created_by_admin, class_name: "AdminAccount", optional: true
+
+  validates :kind, :severity, :status, :title, :body, presence: true
+  validates :kind, inclusion: { in: KINDS }
+  validates :severity, inclusion: { in: SEVERITIES }
+  validates :status, inclusion: { in: STATUSES }
+  validates :title, length: { maximum: 120 }, allow_blank: true
+  validates :body, length: { maximum: 2000 }, allow_blank: true
+  validates :action_label, length: { maximum: 40 }, allow_blank: true
+  URL_KEYS.each do |field|
+    validates field, format: { with: /\Ahttps?:\/\/.+/i, allow_blank: true }
+  end
+  validate :ends_at_after_starts_at
+  validate :at_least_one_channel
+  validate :translations_are_valid
+  before_validation :normalize_translations
+
+  scope :newest, -> { order(created_at: :desc) }
+  scope :published, -> { where(status: "published") }
+  scope :active_now, lambda {
+    now = Time.current
+    published
+      .where("starts_at IS NULL OR starts_at <= ?", now)
+      .where("ends_at IS NULL OR ends_at > ?", now)
+  }
+
+  def self.for_channel(channel)
+    column = CHANNELS[channel.to_sym]
+    raise ArgumentError, "unknown announcement channel: #{channel}" if column.blank?
+
+    active_now.where(column => true)
+  end
+
+  def self.for_app
+    active_now.where("show_on_android = TRUE OR show_on_ios = TRUE")
+  end
+
+  def self.for_platform(platform)
+    case platform.to_s
+    when "android" then for_channel(:android)
+    when "ios" then for_channel(:ios)
+    else for_app
+    end
+  end
+
+  def published?
+    status == "published"
+  end
+
+  def selected_channels
+    CHANNELS.each_with_object([]) do |(key, column), keys|
+      keys << key if public_send(column)
+    end
+  end
+
+  def copy_values_for(locale)
+    loc = locale.to_s
+    if default_locale?(loc)
+      COPY_KEYS.index_with { |key| public_send(key).to_s.presence }
+    else
+      translation_hash(loc)
+    end
+  end
+
+  def filled_locale_codes
+    LocaleResolver.available.select { |loc| locale_has_copy?(loc) }.map(&:to_s)
+  end
+
+  def as_api_json(platform: nil, locale: I18n.locale)
+    {
+      id: id,
+      kind: kind,
+      severity: severity,
+      title: copy_for("title", locale: locale),
+      body: copy_for("body", locale: locale),
+      dismissible: dismissible,
+      action_url: resolved_action_url(platform, locale: locale),
+      action_label: copy_for("action_label", locale: locale).presence,
+      starts_at: starts_at&.iso8601,
+      ends_at: ends_at&.iso8601
+    }
+  end
+
+  def localized_title(locale: I18n.locale)
+    copy_for("title", locale: locale)
+  end
+
+  def localized_body(locale: I18n.locale)
+    copy_for("body", locale: locale)
+  end
+
+  def localized_action_label(locale: I18n.locale)
+    copy_for("action_label", locale: locale)
+  end
+
+  def resolved_action_url(platform, locale: I18n.locale)
+    url = copy_for("action_url", locale: locale)
+    return url if url.present?
+    return nil unless kind == "update"
+
+    case platform.to_s
+    when "android" then MatchLiveTv.play_store_url
+    when "ios" then MatchLiveTv.app_store_url
+    end
+  end
+
+  private
+
+  def copy_for(field, locale: I18n.locale)
+    field = field.to_s
+    locale_chain(locale).each do |loc|
+      value = value_for(loc, field)
+      return value if value.present?
+    end
+    nil
+  end
+
+  def value_for(locale, key)
+    copy_values_for(locale)[key].presence
+  end
+
+  def translation_hash(locale)
+    raw = translations.is_a?(Hash) ? translations : {}
+    values = raw.stringify_keys[locale.to_s]
+    return {} unless values.is_a?(Hash)
+
+    values.stringify_keys
+  end
+
+  def locale_chain(locale)
+    loc = (LocaleResolver.normalize(locale) || I18n.default_locale).to_s
+    LOCALE_FALLBACKS[loc] || [loc, I18n.default_locale.to_s].uniq
+  end
+
+  def locale_has_copy?(locale)
+    values = copy_values_for(locale)
+    values["title"].present? || values["body"].present?
+  end
+
+  def default_locale?(locale)
+    locale.to_s == I18n.default_locale.to_s
+  end
+
+  def normalize_translations
+    self.translations = self.class.sanitize_translations(translations)
+  end
+
+  def self.sanitize_translations(value)
+    raw = coerce_translation_hash(value)
+    LocaleResolver.available.each_with_object({}) do |loc, acc|
+      next if loc.to_s == I18n.default_locale.to_s
+
+      payload = raw[loc.to_s]
+      next unless payload.is_a?(Hash)
+
+      cleaned = COPY_KEYS.each_with_object({}) do |key, fields|
+        text = payload[key].to_s.strip
+        fields[key] = text if text.present?
+      end
+      acc[loc.to_s] = cleaned if cleaned.any?
+    end
+  end
+
+  def self.coerce_translation_hash(value)
+    hash = if value.is_a?(ActionController::Parameters)
+             value.to_unsafe_h
+           elsif value.is_a?(Hash)
+             value
+           else
+             {}
+           end
+    hash.deep_stringify_keys
+  end
+  private_class_method :coerce_translation_hash
+
+  def at_least_one_channel
+    return if show_on_android? || show_on_ios? || show_on_web_public? || show_on_web_private?
+
+    errors.add(:base, :no_channel)
+  end
+
+  def ends_at_after_starts_at
+    return if starts_at.blank? || ends_at.blank?
+    return if ends_at > starts_at
+
+    errors.add(:ends_at, :invalid)
+  end
+
+  def translations_are_valid
+    translation_entries.each do |locale, payload|
+      TITLE_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 120
+      end
+      BODY_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 2000
+      end
+      LABEL_KEYS.each do |key|
+        errors.add(:base, :translation_too_long, locale: locale, field: key) if payload[key].to_s.length > 40
+      end
+      URL_KEYS.each do |key|
+        url = payload[key].to_s
+        next if url.blank? || url.match?(/\Ahttps?:\/\/.+/i)
+
+        errors.add(:base, :translation_invalid_url, locale: locale)
+      end
+    end
+  end
+
+  def translation_entries
+    raw = translations.is_a?(Hash) ? translations : {}
+    raw.stringify_keys.filter_map do |locale, payload|
+      next unless payload.is_a?(Hash)
+
+      [locale, payload.stringify_keys]
+    end
+  end
+end

backend/app/models/club.rb

@@ -1,5 +1,6 @@
 class Club < ApplicationRecord
   include Brandable
+  include Coverable
   include ClubBillingProfile
 
   has_many :club_memberships, dependent: :destroy

backend/app/models/concerns/coverable.rb

@@ -0,0 +1,50 @@
+module Coverable
+  extend ActiveSupport::Concern
+
+  COVER_IMAGE_TYPES = %w[image/png image/jpeg image/webp].freeze
+  MAX_COVER_BYTES = 5.megabytes
+
+  included do
+    has_one_attached :cover_image
+    has_one_attached :cover_slate
+
+    validate :cover_image_file_type, if: -> { cover_image.attached? }
+    validate :cover_image_file_size, if: -> { cover_image.attached? }
+  end
+
+  def cover_image_attached?
+    cover_image.attached?
+  end
+
+  def cover_url
+    return unless cover_image.attached?
+
+    Rails.application.routes.url_helpers.rails_blob_path(cover_image, only_path: true)
+  end
+
+  def effective_cover_url
+    if cover_image.attached?
+      cover_url
+    else
+      cover_parent&.effective_cover_url
+    end
+  end
+
+  private
+
+  def cover_parent
+    nil
+  end
+
+  def cover_image_file_type
+    return if cover_image.content_type.in?(COVER_IMAGE_TYPES)
+
+    errors.add(:cover_image, I18n.t("coverable.errors.invalid_type"))
+  end
+
+  def cover_image_file_size
+    return if cover_image.byte_size <= MAX_COVER_BYTES
+
+    errors.add(:cover_image, I18n.t("coverable.errors.too_large"))
+  end
+end

backend/app/models/match.rb

@@ -1,4 +1,6 @@
 class Match < ApplicationRecord
+  include Coverable
+
   belongs_to :team
   has_many :stream_sessions, dependent: :destroy
 
@@ -174,4 +176,8 @@ class Match < ApplicationRecord
   rescue ArgumentError => e
     errors.add(:scoring_rules, e.message)
   end
+
+  def cover_parent
+    nil
+  end
 end

backend/app/models/plan.rb

@@ -84,6 +84,10 @@ class Plan < ApplicationRecord
     feature("youtube_enabled") == true
   end
 
+  def custom_cover_enabled?
+    feature("custom_cover") == true
+  end
+
   def premium?
     slug.in?(PREMIUM_SLUGS)
   end

backend/app/models/recording.rb

@@ -2,6 +2,8 @@ class Recording < ApplicationRecord
   STATUSES = %w[processing ready expired failed].freeze
   PRIVACY_STATUSES = %w[public unlisted].freeze
   STORAGE_BACKENDS = %w[local s3].freeze
+  STORAGE_POLICIES = %w[temporary retained none].freeze
+  REPLAY_SOURCES = %w[youtube matchlivetv none].freeze
 
   belongs_to :stream_session
   belongs_to :team
@@ -9,6 +11,7 @@ class Recording < ApplicationRecord
   validates :status, inclusion: { in: STATUSES }
   validates :privacy_status, inclusion: { in: PRIVACY_STATUSES }
   validates :storage_backend, inclusion: { in: STORAGE_BACKENDS }
+  validates :storage_policy, inclusion: { in: STORAGE_POLICIES }
 
   scope :not_deleted, -> { where(deleted_at: nil) }
   scope :ready, lambda {
@@ -23,7 +26,16 @@ class Recording < ApplicationRecord
     ready.where(expires_at: ..days.days.from_now)
   }
   scope :expired_pending_purge, lambda {
-    not_deleted.where(status: %w[ready failed]).where("expires_at IS NOT NULL AND expires_at <= ?", Time.current)
+    not_deleted
+      .where(storage_policy: "retained")
+      .where(status: %w[ready failed])
+      .where("expires_at IS NOT NULL AND expires_at <= ?", Time.current)
+  }
+  scope :temporary_media_pending_purge, lambda {
+    not_deleted
+      .where(storage_policy: "temporary")
+      .where(local_media_purged_at: nil)
+      .where("temp_expires_at IS NOT NULL AND temp_expires_at <= ?", Time.current)
   }
   scope :search_replays, lambda { |query|
     q = query.to_s.strip
@@ -46,19 +58,30 @@ class Recording < ApplicationRecord
   end
 
   def playback_stream_url
-    return nil unless ready? && stream_session_id.present?
+    return nil unless ready? && storage_key.present? && stream_session_id.present?
 
     "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/stream"
   end
 
   def thumbnail_url
+    return youtube_thumbnail_url if thumbnail_storage_key.blank? && youtube_video_id.present?
     return nil unless thumbnail_storage_key.present? && stream_session_id.present?
 
     "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/thumbnail"
   end
 
+  def youtube_thumbnail_url
+    return nil if youtube_video_id.blank?
+    return nil if youtube_video_id.to_s.start_with?("mock_")
+
+    meta_url = metadata.is_a?(Hash) ? metadata.dig("youtube", "thumbnail_url") : nil
+    return meta_url if meta_url.present?
+
+    "https://i.ytimg.com/vi/#{youtube_video_id}/hqdefault.jpg"
+  end
+
   def download_api_path
-    return nil unless ready?
+    return nil unless ready? && storage_key.present?
 
     "/api/v1/recordings/#{id}/download"
   end
@@ -70,6 +93,30 @@ class Recording < ApplicationRecord
     "https://www.youtube.com/watch?v=#{youtube_video_id}"
   end
 
+  def temporary_storage?
+    storage_policy == "temporary"
+  end
+
+  def retained_storage?
+    storage_policy == "retained"
+  end
+
+  def local_media_purged?
+    local_media_purged_at.present?
+  end
+
+  # Sorgente fisica del player in archivio (non lo storage policy).
+  def replay_source
+    return "youtube" if youtube_watch_url.present? || (ready? && youtube_video_id.present?)
+    return "matchlivetv" if ready? && storage_key.present?
+
+    "none"
+  end
+
+  def available_in_archive?
+    ready? && (youtube_watch_url.present? || youtube_video_id.present? || storage_key.present?)
+  end
+
   def ready?
     status == "ready" && !deleted? && (expires_at.nil? || expires_at.future?)
   end
@@ -154,7 +201,7 @@ class Recording < ApplicationRecord
   end
 
   def playable_on_site?
-    ready? && storage_key.present?
+    available_in_archive?
   end
 
   def days_until_expiry

backend/app/models/stream_session.rb

@@ -1,7 +1,8 @@
 class StreamSession < ApplicationRecord
   include AASM
 
-  PLATFORMS = %w[matchlivetv youtube facebook twitch].freeze
+  LIVE_PLATFORMS = %w[matchlivetv youtube].freeze
+  PLATFORMS = (LIVE_PLATFORMS + %w[facebook twitch]).freeze
   STATUSES = %w[idle connecting live reconnecting paused ended error].freeze
   PRIVACY_STATUSES = %w[public unlisted private].freeze
 
@@ -10,6 +11,7 @@ class StreamSession < ApplicationRecord
   belongs_to :stream_node, optional: true
   has_many :stream_events, dependent: :destroy
   has_one :score_state, dependent: :destroy
+  has_one :recording
   has_many :device_states, dependent: :destroy
 
   validates :platform, inclusion: { in: PLATFORMS }
@@ -19,6 +21,7 @@ class StreamSession < ApplicationRecord
 
   before_validation :normalize_privacy_status
   before_validation :ensure_publish_token, on: :create
+  before_validation :snapshot_ingest_from_node, if: -> { stream_node.present? }
 
   scope :broadcasting, -> { where(status: %w[live connecting reconnecting paused]) }
   scope :publicly_listed, -> { where(privacy_status: "public") }
@@ -73,6 +76,14 @@ class StreamSession < ApplicationRecord
     end
   end
 
+  def ingest_slug_display
+    stream_node&.slug.presence || ingest_slug
+  end
+
+  def ingest_role_display
+    stream_node&.role.presence || ingest_role
+  end
+
   def rtmp_ingest_url
     # RootEncoder richiede rtmp://host:port/app/stream (due segmenti).
     # MediaMTX path = live/match_{uuid} (no ?token= nel path).
@@ -207,6 +218,11 @@ class StreamSession < ApplicationRecord
     self.privacy_status = "unlisted" if privacy_status == "private"
   end
 
+  def snapshot_ingest_from_node
+    self.ingest_slug = stream_node.slug
+    self.ingest_role = stream_node.role
+  end
+
   def record_ended_timestamps!
     now = Time.current
     update!(ended_at: now) if ended_at.nil?

backend/app/models/team.rb

@@ -1,5 +1,6 @@
 class Team < ApplicationRecord
   include Brandable
+  include Coverable
 
   belongs_to :club
   has_many :user_teams, dependent: :destroy
@@ -99,6 +100,10 @@ class Team < ApplicationRecord
     club
   end
 
+  def cover_parent
+    club
+  end
+
   def assign_slug
     self.slug = Teams::GenerateSlug.call(self) if slug.blank?
   end

backend/app/services/analytics/aggregate.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Analytics
+  class Aggregate
+    BATCH = 500
+    UPSERT_RETRIES = 3
+
+    def call
+      loop do
+        ids = AnalyticsEvent.order(:occurred_at).limit(BATCH).pluck(:id)
+        break if ids.empty?
+
+        events = AnalyticsEvent.where(id: ids).to_a
+        apply_points(events.select { |e| e.event_type == "click" }, :click_count)
+        apply_points(events.select { |e| e.event_type == "move" }, :move_count)
+        apply_stats(events.select { |e| %w[pageview scroll].include?(e.event_type) })
+        AnalyticsEvent.where(id: ids).delete_all
+      end
+    end
+
+    def purge_old!(retention: 30.days)
+      AnalyticsEvent.where("occurred_at < ?", retention.ago).delete_all
+      AnalyticsPageCell.where("day < ?", retention.ago.to_date).delete_all
+      AnalyticsPageStat.where("day < ?", retention.ago.to_date).delete_all
+      AnalyticsPageSnapshot.where("captured_at < ?", retention.ago).find_each do |snap|
+        snap.image.purge if snap.image.attached?
+        snap.destroy!
+      end
+    end
+
+    private
+
+    def apply_points(events, counter_attr)
+      return if events.empty?
+
+      grid = AnalyticsPageCell::GRID_SIZE
+      grouped = Hash.new(0)
+      events.each do |e|
+        next if e.x_pct.nil? || e.y_pct.nil?
+
+        cell_x = [[(e.x_pct.to_f / 100 * grid).floor, grid - 1].min, 0].max
+        cell_y = [[(e.y_pct.to_f / 100 * grid).floor, grid - 1].min, 0].max
+        key = [e.occurred_at.in_time_zone.to_date, e.page_path, e.device, cell_x, cell_y]
+        grouped[key] += e.weight.to_i.clamp(1, 500)
+      end
+
+      now = Time.current
+      grouped.each do |(day, page_path, device, cell_x, cell_y), count|
+        with_unique_retry do
+          cell = AnalyticsPageCell.find_or_initialize_by(
+            day: day, page_path: page_path, device: device, cell_x: cell_x, cell_y: cell_y
+          )
+          cell[counter_attr] = cell[counter_attr].to_i + count
+          cell.created_at ||= now
+          cell.updated_at = now
+          cell.save!
+        end
+      end
+    end
+
+    def apply_stats(events)
+      return if events.empty?
+
+      grouped = {}
+      events.each do |e|
+        day = e.occurred_at.in_time_zone.to_date
+        key = [day, e.page_path, e.device]
+        bucket = grouped[key] ||= { pageviews: 0, scroll_samples: 0, scroll_sum: 0, max_scroll: 0 }
+        case e.event_type
+        when "pageview"
+          bucket[:pageviews] += e.weight.to_i.clamp(1, 500)
+        when "scroll"
+          pct = e.scroll_pct.to_f.round
+          bucket[:scroll_samples] += 1
+          bucket[:scroll_sum] += pct
+          bucket[:max_scroll] = [bucket[:max_scroll], pct].max
+        end
+      end
+
+      now = Time.current
+      grouped.each do |(day, page_path, device), vals|
+        with_unique_retry do
+          stat = AnalyticsPageStat.find_or_initialize_by(day: day, page_path: page_path, device: device)
+          stat.pageview_count = stat.pageview_count.to_i + vals[:pageviews]
+          stat.scroll_samples = stat.scroll_samples.to_i + vals[:scroll_samples]
+          stat.scroll_sum_pct = stat.scroll_sum_pct.to_i + vals[:scroll_sum]
+          stat.max_scroll_pct = [stat.max_scroll_pct.to_i, vals[:max_scroll]].max
+          stat.created_at ||= now
+          stat.updated_at = now
+          stat.save!
+        end
+      end
+    end
+
+    def with_unique_retry
+      attempts = 0
+      begin
+        attempts += 1
+        yield
+      rescue ActiveRecord::RecordNotUnique
+        raise if attempts >= UPSERT_RETRIES
+
+        retry
+      end
+    end
+  end
+end

backend/app/services/analytics/ingest.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Analytics
+  class Ingest
+    MAX_BATCH = 80
+    RATE_LIMIT_PER_MINUTE = 90
+
+    Result = Struct.new(:accepted, :rejected, :rate_limited, keyword_init: true)
+
+    def initialize(events:, remote_ip:)
+      @events = Array(events)
+      @remote_ip = remote_ip.to_s.presence || "unknown"
+    end
+
+    def call
+      return Result.new(accepted: 0, rejected: 0, rate_limited: true) if rate_limited?
+
+      slice = @events.first(MAX_BATCH)
+      accepted = 0
+      rejected = 0
+      rows = []
+
+      slice.each do |raw|
+        attrs = build_attrs(raw)
+        if attrs
+          rows << attrs
+          accepted += 1
+        else
+          rejected += 1
+        end
+      end
+
+      AnalyticsEvent.insert_all(rows) if rows.any?
+      if rows.any?
+        begin
+          Analytics::Aggregate.new.call
+        rescue ActiveRecord::RecordNotUnique => e
+          # Dopo i retry interni: non far fallire la richiesta analytics.
+          Rails.logger.warn("[analytics] aggregate race after retries, enqueue job: #{e.message}")
+          Analytics::AggregateJob.perform_later
+        end
+      end
+
+      Result.new(accepted: accepted, rejected: rejected + (@events.size - slice.size), rate_limited: false)
+    end
+
+    private
+
+    def rate_limited?
+      key = "analytics:ingest:#{@remote_ip}"
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      count = redis.incr(key)
+      redis.expire(key, 60) if count == 1
+      count > RATE_LIMIT_PER_MINUTE
+    rescue StandardError => e
+      Rails.logger.warn("[analytics] rate limit unavailable: #{e.class}")
+      false
+    end
+
+    def build_attrs(raw)
+      data = raw.is_a?(Hash) ? raw.with_indifferent_access : {}
+      event_type = data[:type].to_s.presence || data[:event_type].to_s
+      return nil unless AnalyticsEvent::EVENT_TYPES.include?(event_type)
+
+      device = data[:device].to_s
+      return nil unless AnalyticsEvent::DEVICES.include?(device)
+
+      page_path = PathNormalizer.normalize(data[:path] || data[:page_path])
+      return nil if PathNormalizer.excluded?(page_path)
+      return nil if page_path.length > 200
+
+      occurred_at = parse_time(data[:ts] || data[:occurred_at]) || Time.current
+      weight = data[:n].presence || data[:weight].presence || 1
+      weight = Integer(weight)
+      weight = 1 if weight < 1
+      weight = 500 if weight > 500
+
+      attrs = {
+        page_path: page_path,
+        device: device,
+        event_type: event_type,
+        occurred_at: occurred_at,
+        weight: weight,
+        x_pct: nil,
+        y_pct: nil,
+        scroll_pct: nil,
+        created_at: Time.current,
+        updated_at: Time.current
+      }
+
+      case event_type
+      when "click", "move"
+        x = clamp_pct(data[:x] || data[:x_pct])
+        y = clamp_pct(data[:y] || data[:y_pct])
+        return nil if x.nil? || y.nil?
+
+        attrs[:x_pct] = x
+        attrs[:y_pct] = y
+      when "scroll"
+        scroll = clamp_pct(data[:scroll] || data[:scroll_pct])
+        return nil if scroll.nil?
+
+        attrs[:scroll_pct] = scroll
+      when "pageview"
+        # no extra fields
+      end
+
+      attrs
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def clamp_pct(value)
+      return nil if value.nil?
+
+      n = Float(value)
+      return nil if n.nan? || n.infinite?
+      return nil if n.negative? || n > 100
+
+      n.round(2)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def parse_time(value)
+      return value if value.is_a?(Time) || value.is_a?(ActiveSupport::TimeWithZone)
+      return Time.zone.at(value.to_i / 1000.0) if value.is_a?(Numeric) || value.to_s.match?(/\A\d{10,13}\z/)
+
+      Time.zone.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+end

backend/app/services/analytics/path_normalizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Analytics
+  class PathNormalizer
+    UUID_RE = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+    NUMERIC_RE = /\A\d{6,}\z/
+    TOKENISH_RE = /\A[A-Za-z0-9_\-]{22,}\z/
+
+    EXCLUDED_PREFIXES = %w[/admin /regia /analytics /cable /api /webhooks /internal].freeze
+
+    class << self
+      def normalize(raw_path)
+        path = raw_path.to_s.split("?", 2).first.to_s
+        path = "/" if path.blank?
+        path = "/#{path}" unless path.start_with?("/")
+        path = path.gsub(%r{/{2,}}, "/").chomp("/")
+        path = "/" if path.blank?
+
+        parts = path.split("/").map do |segment|
+          next segment if segment.blank?
+          next ":id" if UUID_RE.match?(segment)
+          next ":id" if NUMERIC_RE.match?(segment)
+          next ":token" if TOKENISH_RE.match?(segment) && segment.match?(/[A-Z]/)
+
+          segment
+        end
+        normalized = parts.join("/")
+        normalized = "/" if normalized.blank?
+        normalized
+      end
+
+      def excluded?(raw_or_normalized)
+        path = normalize(raw_or_normalized)
+        return true if EXCLUDED_PREFIXES.any? { |p| path == p || path.start_with?("#{p}/") }
+        return true if path.match?(%r{\A/live/[^/]+})
+        return true if path.match?(%r{\A/replay/[^/]+})
+
+        false
+      end
+    end
+  end
+end

backend/app/services/analytics/snapshot_ingest.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Analytics
+  class SnapshotIngest
+    MAX_BYTES = 1_800_000
+    MIN_REFRESH = 12.hours
+    RATE_LIMIT_PER_HOUR = 20
+
+    Result = Struct.new(:ok, :skipped, :rate_limited, :error, keyword_init: true)
+
+    def initialize(path:, device:, width:, height:, image:, remote_ip:)
+      @path = path
+      @device = device.to_s
+      @width = width
+      @height = height
+      @image = image
+      @remote_ip = remote_ip.to_s.presence || "unknown"
+    end
+
+    def call
+      return Result.new(ok: false, skipped: false, rate_limited: true) if rate_limited?
+
+      page_path = PathNormalizer.normalize(@path)
+      return Result.new(ok: false, skipped: true, error: "path") if PathNormalizer.excluded?(page_path)
+      return Result.new(ok: false, skipped: true, error: "device") unless AnalyticsEvent::DEVICES.include?(@device)
+      return Result.new(ok: false, skipped: true, error: "image") unless valid_image?
+
+      width = Integer(@width)
+      height = Integer(@height)
+      return Result.new(ok: false, skipped: true, error: "size") if width < 200 || height < 200 || width > 6000 || height > 20000
+
+      snap = AnalyticsPageSnapshot.find_or_initialize_by(page_path: page_path, device: @device)
+      if snap.persisted? && snap.captured_at.present? && snap.captured_at > MIN_REFRESH.ago && snap.image.attached?
+        return Result.new(ok: true, skipped: true)
+      end
+
+      snap.width = width
+      snap.height = height
+      snap.captured_at = Time.current
+      snap.save!
+      snap.image.purge if snap.image.attached?
+      snap.image.attach(
+        io: image_io,
+        filename: "analytics-#{Digest::SHA1.hexdigest(page_path)[0, 12]}-#{@device}.jpg",
+        content_type: "image/jpeg"
+      )
+
+      Result.new(ok: true, skipped: false)
+    rescue ArgumentError, TypeError, ActiveRecord::RecordInvalid => e
+      Result.new(ok: false, skipped: true, error: e.class.name)
+    end
+
+    private
+
+    def rate_limited?
+      key = "analytics:snapshot:#{@remote_ip}"
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      count = redis.incr(key)
+      redis.expire(key, 3600) if count == 1
+      count > RATE_LIMIT_PER_HOUR
+    rescue StandardError => e
+      Rails.logger.warn("[analytics] snapshot rate limit unavailable: #{e.class}")
+      false
+    end
+
+    def valid_image?
+      return false if @image.blank?
+      return false unless @image.respond_to?(:tempfile) || @image.respond_to?(:read)
+      return false if @image.respond_to?(:size) && @image.size.to_i > MAX_BYTES
+
+      content_type = @image.content_type.to_s if @image.respond_to?(:content_type)
+      content_type.blank? || content_type.start_with?("image/")
+    end
+
+    def image_io
+      if @image.respond_to?(:tempfile)
+        @image.tempfile.rewind
+        @image.tempfile
+      else
+        StringIO.new(@image.read)
+      end
+    end
+  end
+end

backend/app/services/contacts/submit_inquiry.rb

@@ -0,0 +1,102 @@
+module Contacts
+  class SubmitInquiry
+    TOPICS = %w[commercial support privacy].freeze
+    LIMIT = 5
+    WINDOW = 1.hour
+    NAME_MAX = 120
+    CLUB_MAX = 160
+    MESSAGE_MIN = 10
+    MESSAGE_MAX = 4_000
+
+    Result = Struct.new(:ok, :error, keyword_init: true)
+
+    def self.call(params:, ip:)
+      new(params: params, ip: ip).call
+    end
+
+    def initialize(params:, ip:)
+      @params = params
+      @ip = ip.to_s.presence || "unknown"
+    end
+
+    def call
+      if honeypot_filled?
+        record_attempt
+        return Result.new(ok: true, error: nil)
+      end
+
+      return Result.new(ok: false, error: :throttled) if throttled?
+
+      error = validate
+      return Result.new(ok: false, error: error) if error
+
+      record_attempt
+      deliver
+      Result.new(ok: true, error: nil)
+    end
+
+    private
+
+    def honeypot_filled?
+      @params[:website].to_s.strip.present?
+    end
+
+    def throttled?
+      current_count >= LIMIT
+    end
+
+    def validate
+      return :privacy_required unless @params[:accept_privacy].to_s == "1"
+      return :invalid if name.blank? || name.length > NAME_MAX
+      return :invalid_email if email.blank? || email !~ URI::MailTo::EMAIL_REGEXP
+      return :invalid if club_name.length > CLUB_MAX
+      return :invalid unless TOPICS.include?(topic)
+      return :invalid_message if message.length < MESSAGE_MIN || message.length > MESSAGE_MAX
+
+      nil
+    end
+
+    def deliver
+      mail = ContactMailer.inquiry(
+        name: name,
+        email: email,
+        club_name: club_name,
+        topic: topic,
+        message: message
+      )
+      MatchLiveTv.deliver_mail(mail)
+    end
+
+    def record_attempt
+      Rails.cache.write(cache_key, current_count + 1, expires_in: WINDOW, raw: true)
+    end
+
+    def current_count
+      Rails.cache.read(cache_key, raw: true).to_i
+    end
+
+    def cache_key
+      "contacts:inquiry:#{@ip}"
+    end
+
+    def name
+      @params[:name].to_s.strip
+    end
+
+    def email
+      @params[:email].to_s.strip.downcase
+    end
+
+    def club_name
+      @params[:club_name].to_s.strip
+    end
+
+    def topic
+      @params[:topic].to_s.strip
+    end
+
+    def message
+      @params[:message].to_s.strip
+    end
+  end
+end

backend/app/services/mediamtx/client.rb

@@ -4,6 +4,9 @@ module Mediamtx
   class Client
     class Error < StandardError; end
 
+    CREATE_PATH_RETRIES = -> { ENV.fetch("MEDIAMTX_CREATE_RETRIES", "5").to_i }
+    CREATE_PATH_RETRY_BASE_SECS = -> { ENV.fetch("MEDIAMTX_CREATE_RETRY_BASE_SECS", "0.4").to_f }
+
     def self.for_session(session)
       new(base_url: session.mediamtx_api_base_url)
     end
@@ -19,6 +22,19 @@ module Mediamtx
 
     attr_reader :base_url
 
+    # Health probe for CPX readiness (GET /v3/paths/list).
+    def reachable?(timeout: 2)
+      conn = Faraday.new(url: @base_url) do |f|
+        f.adapter Faraday.default_adapter
+        f.options.open_timeout = timeout
+        f.options.timeout = timeout
+      end
+      response = conn.get("/v3/paths/list")
+      response.success?
+    rescue Faraday::Error
+      false
+    end
+
     def create_path(session)
       path = session.mediamtx_path_name
       # record: false finché non c'è publisher — con alwaysAvailable MediaMTX registrerebbe
@@ -28,9 +44,11 @@ module Mediamtx
         overridePublisher: true
       )
       body[:alwaysAvailable] = true
-      body[:alwaysAvailableFile] = slate_file_path
+      body[:alwaysAvailableFile] = slate_file_path(session)
       # YouTube: telefono → MediaMTX; relay copy verso RTMPS in sidekiq.
-      response = @conn.post("/v3/config/paths/add/#{CGI.escape(path)}", body)
+      response = with_connection_retries("create_path #{path}") do
+        @conn.post("/v3/config/paths/add/#{CGI.escape(path)}", body)
+      end
       unless response.success?
         err = response.body.is_a?(Hash) ? response.body["error"] : response.body
         raise Error, "MediaMTX path create failed: #{response.status} #{err}"
@@ -74,14 +92,55 @@ module Mediamtx
       set_always_available(session, enabled: true)
     end
 
-      # Slate alwaysAvailable: copertina sullo stesso path quando il telefono è offline.
+    # Garantisce path config + slate: se MediaMTX ha perso la config (restart → all_others),
+    # in pausa non resterebbe nessuno stream verso HLS/YouTube.
+    def ensure_path_with_slate!(session)
+      path = session.mediamtx_path_name
+      response = @conn.get("/v3/config/paths/get/#{CGI.escape(path)}")
+      missing = response.status == 404 ||
+        (response.body.is_a?(Hash) && response.body["error"].present?)
+
+      if missing
+        forget_always_available(path)
+        begin
+          create_path(session)
+        rescue Error
+          # Path creato in parallelo o già presente: forza solo la slate.
+          forget_always_available(path)
+          set_always_available(session, enabled: true)
+        end
+        return true
+      end
+
+      conf = response.body.is_a?(Hash) ? response.body : {}
+      desired = slate_file_path(session)
+      if conf["alwaysAvailable"] == true && conf["alwaysAvailableFile"].to_s == desired.to_s
+        remember_always_available(path, enabled: true)
+        return true
+      end
+
+      forget_always_available(path)
+      set_always_available(session, enabled: true)
+    end
+
+    # Spegnere record solo se attivo: ogni PATCH path ricarica MediaMTX e distrugge i muxer HLS.
+    def disable_recording_if_active!(session)
+      path = session.mediamtx_path_name
+      response = @conn.get("/v3/config/paths/get/#{CGI.escape(path)}")
+      return true unless response.success?
+      return true unless response.body.is_a?(Hash) && response.body["record"] == true
+
+      set_path_recording(session, enabled: false)
+    end
+
+    # Slate alwaysAvailable: copertina sullo stesso path quando il telefono è offline.
     # Resta accesa anche con publisher in onda (MediaMTX usa il publisher se presente).
     def set_always_available(session, enabled:)
       path = session.mediamtx_path_name
       return true if always_available_remembered?(path, enabled: enabled)
 
       body = if enabled
-               { alwaysAvailable: true, alwaysAvailableFile: slate_file_path }
+               { alwaysAvailable: true, alwaysAvailableFile: slate_file_path(session) }
              else
                { alwaysAvailable: false }
              end
@@ -120,6 +179,23 @@ module Mediamtx
 
     private
 
+    def with_connection_retries(label)
+      attempts = [CREATE_PATH_RETRIES.call, 1].max
+      base = CREATE_PATH_RETRY_BASE_SECS.call
+      try = 0
+      begin
+        try += 1
+        yield
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+        raise if try >= attempts
+
+        sleep_secs = base * (2**(try - 1))
+        Rails.logger.warn("[Mediamtx::Client] #{label} retry #{try}/#{attempts} after #{e.class}: #{e.message} (sleep #{sleep_secs}s)")
+        sleep(sleep_secs)
+        retry
+      end
+    end
+
     def recording_body(session, enabled:)
       ent = session.match.team.entitlements
       can_record = ent.recording_enabled_for_mediamtx?
@@ -173,7 +249,13 @@ module Mediamtx
       SCRIPT
     end
 
-    def slate_file_path
+    def slate_file_path(session)
+      return default_slate_file_path if session.blank?
+
+      Streams::SlateDistributor.slate_path_for_session(session)
+    end
+
+    def default_slate_file_path
       ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
     end
 

backend/app/services/mediamtx/publisher_sync.rb

@@ -79,9 +79,8 @@ module Mediamtx
     end
 
     def restore_slate_path!(session)
-      return if session.platform == "matchlivetv"
+      # Anche su matchlivetv: dopo restart MediaMTX la path può cadere su all_others senza slate.
-
+      Client.for_session(session).ensure_path_with_slate!(session)
-      Client.for_session(session).set_always_available(session, enabled: true)
     rescue Client::Error => e
       Rails.logger.warn("[PublisherSync] enable slate session=#{session.id}: #{e.message}")
     end
@@ -146,6 +145,14 @@ module Mediamtx
       nil
     end
 
+    def self.remember_recording_off!(session_id)
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      redis.set("mediamtx:recording:#{session_id}", "0", ex: 48.hours.to_i)
+      redis.set(format("mediamtx:recording:patched_at:%s", session_id), Time.current.to_i, ex: 48.hours.to_i)
+    rescue Redis::BaseError
+      nil
+    end
+
     def recording_state_key(session_id)
       "mediamtx:recording:#{session_id}"
     end

backend/app/services/recordings/clear_temporary_media.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Recordings
+  # Rimuove solo l'MP4 temporaneo su object storage. Non soft-delete, non tocca YouTube.
+  class ClearTemporaryMedia
+    def initialize(recording, reason: :verified, force: false)
+      @recording = recording
+      @reason = reason
+      @force = force
+    end
+
+    def call
+      unless @recording.temporary_storage?
+        Rails.logger.info(
+          "[Recordings::ClearTemporaryMedia] skip recording=#{@recording.id} not_temporary"
+        )
+        return @recording
+      end
+
+      if @recording.local_media_purged?
+        Rails.logger.info(
+          "[Recordings::ClearTemporaryMedia] already_purged recording=#{@recording.id}"
+        )
+        return @recording
+      end
+
+      unless allowed?
+        Rails.logger.info(
+          "[Recordings::ClearTemporaryMedia] skip recording=#{@recording.id} " \
+          "reason=not_verified_and_not_expired force=#{@force}"
+        )
+        return @recording
+      end
+
+      delete_video_object!
+      @recording.update!(
+        storage_key: nil,
+        byte_size: nil,
+        local_media_purged_at: Time.current
+      )
+
+      Rails.logger.info(
+        "[Recordings::ClearTemporaryMedia] purged recording=#{@recording.id} " \
+        "reason=#{@reason} youtube_verified=#{@recording.youtube_verified_at.present?} " \
+        "youtube_video_id=#{@recording.youtube_video_id.inspect}"
+      )
+      @recording
+    end
+
+    private
+
+    def allowed?
+      return true if @force
+      return true if @recording.youtube_verified_at.present?
+      return true if @recording.temp_expires_at.present? && @recording.temp_expires_at <= Time.current
+
+      false
+    end
+
+    def delete_video_object!
+      key = @recording.storage_key
+      return if key.blank?
+
+      Recordings::Storage.new.delete(key: key)
+    rescue Recordings::Storage::Error => e
+      # File già assente → ok (idempotente)
+      Rails.logger.info(
+        "[Recordings::ClearTemporaryMedia] storage delete recording=#{@recording.id}: #{e.message}"
+      )
+    end
+  end
+end

backend/app/services/recordings/finalize_session.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Recordings
   class FinalizeSession
     def initialize(session)
@@ -5,29 +7,69 @@ module Recordings
     end
 
     def call
-      team = @session.match.team
+      policy = Recordings::StoragePolicy.call(@session)
-      return unless team.entitlements.can_create_recordings?
+      return if policy == Recordings::StoragePolicy::NONE
 
-      retention_days = team.entitlements.recording_retention_days
+      team = @session.match.team
-      expires_at = retention_days.positive? ? retention_days.days.from_now : nil
+      attrs = attributes_for(policy, team)
 
       recording = Recording.find_or_initialize_by(stream_session: @session)
-      recording.assign_attributes(
+      if skip_reinitialize?(recording)
+        Rails.logger.info(
+          "[Recordings::FinalizeSession] skip already-finalized " \
+          "recording=#{recording.id} status=#{recording.status}"
+        )
+        return recording
+      end
+      recording.assign_attributes(attrs)
+      recording.save!
+
+      Rails.logger.info(
+        "[Recordings::FinalizeSession] session=#{@session.id} recording=#{recording.id} " \
+        "storage_policy=#{policy} expires_at=#{recording.expires_at.inspect} " \
+        "temp_expires_at=#{recording.temp_expires_at.inspect}"
+      )
+      recording
+    end
+
+    private
+
+    def skip_reinitialize?(recording)
+      return false unless recording.persisted?
+
+      recording.ready? ||
+        recording.status == "processing" ||
+        recording.storage_key.present?
+    end
+
+    def attributes_for(policy, team)
+      {
         team: team,
         status: "processing",
         title: default_title,
         privacy_status: privacy_from_session,
         storage_path: @session.mediamtx_path_name,
         recorded_at: @session.ended_at || Time.current,
-        expires_at: expires_at,
+        storage_policy: policy,
+        expires_at: archive_expires_at(policy, team),
+        temp_expires_at: temp_expires_at_for(policy),
         error_message: nil,
-        metadata: initial_metadata(team)
+        metadata: initial_metadata(policy, team)
-      )
+      }
-      recording.save!
-      recording
     end
 
-    private
+    def archive_expires_at(policy, team)
+      return nil if policy == Recordings::StoragePolicy::TEMPORARY
+
+      retention_days = team.entitlements.recording_retention_days
+      retention_days.positive? ? retention_days.days.from_now : nil
+    end
+
+    def temp_expires_at_for(policy)
+      return nil unless policy == Recordings::StoragePolicy::TEMPORARY
+
+      MatchLiveTv.youtube_temp_replay_retention_hours.hours.from_now
+    end
 
     def default_title
       match = @session.match
@@ -38,12 +80,13 @@ module Recordings
       @session.privacy_status == "public" ? "public" : "unlisted"
     end
 
-    def initial_metadata(team)
+    def initial_metadata(policy, team)
-      ent = team.entitlements
       {
         "source_platform" => @session.platform,
         "session_privacy" => @session.privacy_status,
-        "auto_publish_youtube" => ent.premium_full? && ent.youtube_enabled? && @session.platform == "youtube",
+        # Re-upload automatico disabilitato: le live YouTube usano VerifyYoutubeReplay.
+        "auto_publish_youtube" => false,
+        "storage_policy" => policy,
         "ai" => {}
       }
     end

backend/app/services/recordings/pull_from_cloud_node.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "fileutils"
+require "net/http"
+require "uri"
+
+module Recordings
+  # Recupera i segmenti MediaMTX dal disco del CPX (agent :9100) verso un tmpdir locale.
+  class PullFromCloudNode
+    class Error < StandardError; end
+
+    def initialize(session)
+      @session = session
+    end
+
+    def applicable?
+      node = @session.stream_node
+      node.present? && node.role == "cloud" && agent_url.present?
+    end
+
+    # @return [String, nil] directory con i file, o nil se il nodo non è cloud / 404
+    def fetch
+      return unless applicable?
+
+      dest = Dir.mktmpdir("mltv-cpx-rec-")
+      uri = recordings_uri
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = ENV.fetch("STREAM_NODE_RECORDINGS_PULL_TIMEOUT", "180").to_i
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{agent_secret}" if agent_secret.present?
+      res = http.request(req)
+      if res.is_a?(Net::HTTPNotFound)
+        FileUtils.remove_entry(dest)
+        return nil
+      end
+      unless res.is_a?(Net::HTTPSuccess) && res.body.present?
+        FileUtils.remove_entry(dest)
+        raise Error, "agent GET recordings HTTP #{res.code} #{res.body.to_s.truncate(200)}"
+      end
+
+      tar_path = File.join(dest, "recordings.tar.gz")
+      File.binwrite(tar_path, res.body)
+      unpack!(tar_path, dest)
+      FileUtils.rm_f(tar_path)
+      dest
+    rescue StandardError
+      FileUtils.remove_entry(dest) if dest && Dir.exist?(dest)
+      raise
+    end
+
+    def cleanup_remote!
+      return unless applicable?
+
+      uri = recordings_uri
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = 15
+      req = Net::HTTP::Delete.new(uri)
+      req["Authorization"] = "Bearer #{agent_secret}" if agent_secret.present?
+      res = http.request(req)
+      return if res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPNotFound)
+
+      Rails.logger.warn(
+        "[Recordings::PullFromCloudNode] delete HTTP #{res.code} session=#{@session.id}"
+      )
+    rescue StandardError => e
+      Rails.logger.warn("[Recordings::PullFromCloudNode] delete #{e.class}: #{e.message}")
+    end
+
+    private
+
+    def recordings_uri
+      path = @session.mediamtx_path_name.to_s
+      URI.parse("#{agent_url.chomp('/')}/recordings/#{CGI.escape(path)}")
+    end
+
+    def agent_url
+      ENV["STREAM_NODE_RELAY_AGENT_URL"].presence || @session.stream_node&.relay_agent_url
+    end
+
+    def agent_secret
+      ENV["STREAM_NODE_AGENT_SECRET"].presence || "mediamtx_webhook_dev_secret"
+    end
+
+    def unpack!(tar_path, dest)
+      ok = system("tar", "-xzf", tar_path, "-C", dest, out: File::NULL, err: File::NULL)
+      raise Error, "tar extract failed" unless ok
+    end
+  end
+end

backend/app/services/recordings/storage_policy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Recordings
+  # Decisione centralizzata: temporary (YouTube) | retained (HLS) | none.
+  class StoragePolicy
+    TEMPORARY = "temporary"
+    RETAINED = "retained"
+    NONE = "none"
+    POLICIES = [TEMPORARY, RETAINED, NONE].freeze
+
+    def self.call(session)
+      new(session).call
+    end
+
+    def initialize(session)
+      @session = session
+    end
+
+    def call
+      team = @session.match.team
+      ent = team.entitlements
+
+      return NONE unless ent.can_create_recordings?
+
+      if youtube_destination?
+        TEMPORARY
+      else
+        RETAINED
+      end
+    end
+
+    def youtube_destination?
+      @session.platform.to_s == "youtube"
+    end
+  end
+end

backend/app/services/recordings/upload_from_session.rb

@@ -9,8 +9,9 @@ module Recordings
     def call
       recording = Recording.find_by(stream_session: @session)
       return unless recording&.status == "processing"
+      return if recording.storage_key.present?
 
-      source_files = local_source_files
+      source_files = collect_source_files
       if source_files.empty?
         fail_recording!(recording, "Nessun file di registrazione trovato")
         cleanup_mediamtx_path
@@ -35,23 +36,52 @@ module Recordings
         error_message: nil
       )
 
+      Rails.logger.info(
+        "[Recordings::UploadFromSession] ready recording=#{recording.id} " \
+        "storage_policy=#{recording.storage_policy} key=#{storage_key} bytes=#{byte_size}"
+      )
+
       cleanup_local_sources(source_files, merged_path)
+      cleanup_cloud_pull!
+      cleanup_remote_recordings!
       cleanup_mediamtx_path
       Recordings::PostProcessJob.perform_async(recording.id)
       recording
-    rescue Error, Recordings::Storage::Error => e
+    rescue Error, Recordings::Storage::Error, Recordings::PullFromCloudNode::Error => e
       recording = Recording.find_by(stream_session: @session)
       fail_recording!(recording, e.message) if recording
       raise
     ensure
       FileUtils.rm_f(@merged_temp_path) if @merged_temp_path && File.exist?(@merged_temp_path)
+      cleanup_cloud_pull! unless recording_ready?
     end
 
     private
 
+    def collect_source_files
+      files = local_source_files
+      return files if files.any?
+
+      puller = Recordings::PullFromCloudNode.new(@session)
+      return [] unless puller.applicable?
+
+      3.times do |i|
+        cleanup_cloud_pull!
+        @cloud_pull_dir = puller.fetch
+        files = scan_recording_files(@cloud_pull_dir)
+        return files if files.any?
+
+        sleep 2 if i < 2
+      end
+      []
+    end
+
     def local_source_files
-      base = File.join(MatchLiveTv.recordings_local_path, @session.mediamtx_path_name)
+      scan_recording_files(File.join(MatchLiveTv.recordings_local_path, @session.mediamtx_path_name))
-      return [] unless Dir.exist?(base)
+    end
+
+    def scan_recording_files(base)
+      return [] if base.blank? || !Dir.exist?(base)
 
       Dir.glob(File.join(base, "**", "*"))
          .select { |path| File.file?(path) && path.match?(/\.(mp4|fmp4|m4s|ts)$/i) }
@@ -83,7 +113,11 @@ module Recordings
     end
 
     def object_key(recording)
-      "teams/#{recording.team_id}/sessions/#{@session.id}/replay.mp4"
+      if recording.temporary_storage?
+        "temporary_replays/teams/#{recording.team_id}/sessions/#{@session.id}/replay.mp4"
+      else
+        "teams/#{recording.team_id}/sessions/#{@session.id}/replay.mp4"
+      end
     end
 
     def cleanup_local_sources(source_files, merged_path)
@@ -100,6 +134,24 @@ module Recordings
       Rails.logger.warn("[Recordings::UploadFromSession] delete_path: #{e.message}")
     end
 
+    def cleanup_cloud_pull!
+      return if @cloud_pull_dir.blank? || !Dir.exist?(@cloud_pull_dir)
+
+      FileUtils.remove_entry(@cloud_pull_dir)
+      @cloud_pull_dir = nil
+    rescue StandardError
+      nil
+    end
+
+    def cleanup_remote_recordings!
+      Recordings::PullFromCloudNode.new(@session).cleanup_remote!
+    end
+
+    def recording_ready?
+      rec = Recording.find_by(stream_session: @session)
+      rec&.status == "ready"
+    end
+
     def fail_recording!(recording, message)
       recording.update!(status: "failed", error_message: message)
       cleanup_mediamtx_path

backend/app/services/recordings/verify_youtube_replay.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Recordings
+  # Collega la live YouTube (broadcast_id) al VOD e aggiorna metadata recording.
+  class VerifyYoutubeReplay
+    class Error < StandardError; end
+
+    Result = Struct.new(:status, :message, keyword_init: true) do
+      def ok?
+        status == :ok
+      end
+
+      def retriable?
+        status == :pending
+      end
+    end
+
+    def initialize(recording)
+      @recording = recording
+    end
+
+    def call
+      unless @recording.temporary_storage?
+        return Result.new(status: :skipped, message: "not_temporary")
+      end
+
+      if @recording.youtube_verified_at.present? && @recording.youtube_video_id.present?
+        return Result.new(status: :ok, message: "already_verified")
+      end
+
+      session = @recording.stream_session
+      broadcast_id = session&.youtube_broadcast_id
+      if broadcast_id.blank?
+        Rails.logger.warn(
+          "[Recordings::VerifyYoutubeReplay] missing broadcast_id recording=#{@recording.id}"
+        )
+        return Result.new(status: :failed, message: "missing_broadcast_id")
+      end
+
+      info = Youtube::VodStatus.new(@recording.team, channel: "team").fetch(broadcast_id)
+      unless info.ready
+        Rails.logger.info(
+          "[Recordings::VerifyYoutubeReplay] not_ready recording=#{@recording.id} " \
+          "video=#{broadcast_id} upload_status=#{info.upload_status.inspect}"
+        )
+        return Result.new(status: :pending, message: "vod_not_ready")
+      end
+
+      info = enable_embed_if_needed!(info)
+      apply_verified!(info)
+      Rails.logger.info(
+        "[Recordings::VerifyYoutubeReplay] ok recording=#{@recording.id} " \
+        "youtube_video_id=#{info.video_id} embeddable=#{info.embeddable}"
+      )
+      Result.new(status: :ok, message: "verified")
+    rescue Youtube::VodStatus::Error => e
+      Rails.logger.warn(
+        "[Recordings::VerifyYoutubeReplay] api_error recording=#{@recording.id}: #{e.message}"
+      )
+      Result.new(status: :pending, message: e.message)
+    end
+
+    private
+
+    def apply_verified!(info)
+      meta = @recording.metadata.is_a?(Hash) ? @recording.metadata.deep_dup : {}
+      yt = meta.fetch("youtube", {}).merge(
+        "broadcast_id" => @recording.stream_session.youtube_broadcast_id,
+        "thumbnail_url" => info.thumbnail_url,
+        "privacy_status" => info.privacy_status,
+        "upload_status" => info.upload_status,
+        "embeddable" => info.embeddable,
+        "verified_via" => "live_broadcast"
+      ).compact
+
+      attrs = {
+        youtube_video_id: info.video_id,
+        youtube_verified_at: Time.current,
+        youtube_published_at: @recording.youtube_published_at || Time.current,
+        metadata: meta.merge("youtube" => yt)
+      }
+      attrs[:duration_secs] = info.duration_secs if info.duration_secs.to_i.positive?
+      attrs[:title] = info.title if info.title.present? && @recording.title.blank?
+
+      @recording.update!(attrs)
+    end
+
+    def enable_embed_if_needed!(info)
+      return info if info.embeddable != false
+      return info if info.video_id.to_s.start_with?("mock_")
+
+      session = @recording.stream_session
+      Youtube::BroadcastService.new(session.match.team).enable_video_embed!(
+        info.video_id,
+        privacy_status: info.privacy_status
+      )
+      refreshed = Youtube::VodStatus.new(@recording.team, channel: "team").fetch(info.video_id)
+      refreshed.ready ? refreshed : info
+    rescue Youtube::BroadcastService::Error, Youtube::VodStatus::Error => e
+      Rails.logger.warn(
+        "[Recordings::VerifyYoutubeReplay] enable_embed recording=#{@recording.id}: #{e.message}"
+      )
+      info
+    end
+  end
+end

backend/app/services/sessions/apply_client_info.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sessions
+  # Normalizza e applica fingerprint del client (OS, app, device, operatore)
+  # sulla sessione, a create e/o a ogni telemetry.
+  class ApplyClientInfo
+    OS_VALUES = %w[android ios].freeze
+    MAX_LEN = 80
+
+    ATTRS = %i[
+      client_os app_version app_build device_manufacturer device_model os_version carrier
+    ].freeze
+
+    def self.call(session, raw)
+      new(session, raw).call
+    end
+
+    def initialize(session, raw)
+      @session = session
+      @raw = normalize_hash(raw)
+    end
+
+    def call
+      attrs = extract_attrs
+      return @session if attrs.empty?
+
+      @session.assign_attributes(attrs)
+      @session.save! if @session.persisted? && @session.changed?
+      @session
+    end
+
+    private
+
+    def normalize_hash(raw)
+      return {} if raw.blank?
+
+      data = raw.respond_to?(:to_unsafe_h) ? raw.to_unsafe_h : raw
+      data = data.to_h if data.respond_to?(:to_h)
+      data.with_indifferent_access
+    rescue StandardError
+      {}
+    end
+
+    def extract_attrs
+      attrs = {}
+
+      os = @raw[:os].presence || @raw[:client_os].presence
+      os = os.to_s.downcase.strip
+      attrs[:client_os] = os if OS_VALUES.include?(os)
+
+      {
+        app_version: %i[app_version version],
+        app_build: %i[app_build build build_number],
+        device_manufacturer: %i[device_manufacturer manufacturer],
+        device_model: %i[device_model model],
+        os_version: %i[os_version system_version],
+        carrier: %i[carrier network_operator operator]
+      }.each do |column, keys|
+        value = keys.map { |k| @raw[k] }.find(&:present?)
+        next if value.blank?
+
+        attrs[column] = truncate(value.to_s.strip)
+      end
+
+      attrs
+    end
+
+    def truncate(value)
+      value.bytesize <= MAX_LEN ? value : value.byteslice(0, MAX_LEN)
+    end
+  end
+end

backend/app/services/sessions/create.rb

@@ -26,6 +26,7 @@ module Sessions
         target_fps: @params[:target_fps] || 30,
         status: "idle"
       )
+      Sessions::ApplyClientInfo.call(session, @params[:client])
 
       youtube_channel = nil
       if session.platform == "youtube"
@@ -37,6 +38,8 @@ module Sessions
         session.stream_node = Streams::NodeRegistry.allocate!
         session.save!
         Scoring::Engine.ensure_score_for(session)
+        Streams::CoverSlateEnsurer.ensure_for!(@match)
+        Streams::SlateDistributor.ensure_for!(session)
         Mediamtx::Client.for_session(session).create_path(session)
         log_event(
           session,
@@ -44,22 +47,56 @@ module Sessions
           {
             created: true,
             platform: session.platform,
-            stream_node: session.stream_node&.slug
+            stream_node: session.stream_node&.slug,
-          }
+            client_os: session.client_os,
+            app_version: session.app_version,
+            device_model: session.device_model
+          }.compact
         )
       end
 
+      kick_autoscaler_if_soft_limit!
+
       if session.platform == "youtube"
         YoutubeBroadcastSetupJob.perform_later(session.id, youtube_channel)
       end
 
       session
     rescue Streams::NodeRegistry::NoCapacityError => e
-      raise Teams::EntitlementError.new(e.message, code: "stream_capacity_exhausted")
+      raise_no_capacity!(e)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      raise Streams::IngestUnavailableError, "Ingest temporaneamente non disponibile (#{e.class})"
+    rescue Mediamtx::Client::Error => e
+      if e.message.to_s.match?(/failed to open|Connection refused|Timeout|timed out/i)
+        raise Streams::IngestUnavailableError, e.message
+      end
+      raise
     end
 
     private
 
+    def raise_no_capacity!(error)
+      if Streams::Autoscaler.enabled?
+        Streams::AutoscalerJob.kick!
+        raise Teams::EntitlementError.new(
+          "Capacità streaming in espansione. Riprova tra poco.",
+          code: "stream_capacity_scaling"
+        )
+      end
+
+      raise Teams::EntitlementError.new(error.message, code: "stream_capacity_exhausted")
+    end
+
+    def kick_autoscaler_if_soft_limit!
+      return unless Streams::Autoscaler.enabled?
+
+      free = Streams::Autoscaler.metrics[:free_slots].to_i
+      return if free > Streams::Autoscaler.soft_free_slots
+
+      Streams::AutoscalerJob.kick!
+    end
+
+
     def assert_youtube_channel!(youtube_channel)
       resolver = Youtube::CredentialResolver.new(@match.team, channel: youtube_channel)
       if resolver.resolve.blank?

backend/app/services/sessions/pause.rb

@@ -7,11 +7,13 @@ module Sessions
     def call
       cancel_timeout_job
       @session.pause! if @session.may_pause?
-      Mediamtx::PublisherSync.forget_recording_state!(@session.id)
       begin
         mtx = Mediamtx::Client.for_session(@session)
-        mtx.set_path_recording(@session, enabled: false)
+        # Ricrea/riallinea slate prima di spegnere l'RTMP del telefono.
-        mtx.set_always_available(@session, enabled: true)
+        mtx.ensure_path_with_slate!(@session)
+        # PATCH recording solo se era attivo (evita kill muxer HLS a ogni pausa).
+        mtx.disable_recording_if_active!(@session)
+        Mediamtx::PublisherSync.remember_recording_off!(@session.id)
       rescue Mediamtx::Client::Error => e
         Rails.logger.warn("[Sessions::Pause] MediaMTX: #{e.message}")
       end

backend/app/services/sessions/stop.rb

@@ -12,7 +12,7 @@ module Sessions
       complete_youtube_broadcast! if @session.youtube_broadcast_id.present?
 
       recording = Recordings::FinalizeSession.new(@session).call
-      Recordings::UploadJob.perform_async(@session.id) if recording
+      Recordings::UploadJob.perform_async(@session.id) if recording&.status == "processing"
       remove_mediamtx_paths!
 
       log_event("ended")

backend/app/services/streams/autoscaler.rb

@@ -136,6 +136,8 @@ module Streams
 
     def reconcile!
       actions = []
+      actions.concat(promote_provisioning_nodes!)
+      actions.concat(reclaim_stuck_provisioning!)
       m = self.class.metrics
 
       if need_capacity?(m) && can_provision?(m)
@@ -170,6 +172,30 @@ module Streams
 
     private
 
+    def promote_provisioning_nodes!
+      actions = []
+      StreamNode.where(status: "provisioning").find_each do |node|
+        next unless Streams::NodeHealth.promote_if_healthy!(node)
+
+        actions << :"ready_#{node.slug}"
+        Rails.logger.info("[Streams::Autoscaler] promoted #{node.slug} to ready")
+      end
+      actions
+    end
+
+    def reclaim_stuck_provisioning!
+      actions = []
+      stuck_after = ENV.fetch("STREAM_NODE_PROVISIONING_STUCK_MINUTES", "15").to_i.minutes.ago
+      StreamNode.where(status: "provisioning").where("created_at < ?", stuck_after).find_each do |node|
+        @provisioner.decommission!(node)
+        actions << :"reclaim_#{node.slug}"
+        Rails.logger.warn("[Streams::Autoscaler] decommissioned stuck provisioning #{node.slug}")
+      rescue NodeProvisioner::BusyError, NodeProvisioner::Error => e
+        Rails.logger.warn("[Streams::Autoscaler] reclaim #{node.slug}: #{e.message}")
+      end
+      actions
+    end
+
     def need_capacity?(m)
       m[:free_slots] <= self.class.soft_free_slots
     end

backend/app/services/streams/cover_resolver.rb

@@ -0,0 +1,77 @@
+module Streams
+  # Catena effective cover: partita → squadra → società → default Match Live TV.
+  class CoverResolver
+    Result = Struct.new(:record, :source, :cover_url, :slate_local_path, keyword_init: true)
+
+    DEFAULT_COVER_URL = "/images/copertina-canale.png".freeze
+
+    def initialize(match)
+      @match = match
+      @team = match.team
+      @club = @team.club
+      @entitlements = @team.entitlements
+    end
+
+    def effective_cover_url
+      resolve&.cover_url || default_cover_url
+    end
+
+    def cover_source
+      resolve&.source || "default"
+    end
+
+    def resolve
+      return nil unless @entitlements.can_use_custom_cover?
+
+      candidates.each do |record, source|
+        next unless record.cover_image.attached?
+        next unless record.cover_slate.attached?
+
+        path = CoverSlatePaths.local_path_for(record)
+        next if path.blank?
+
+        return Result.new(
+          record: record,
+          source: source,
+          cover_url: blob_path(record.cover_image),
+          slate_local_path: path
+        )
+      end
+
+      nil
+    end
+
+    # Restituisce il record con cover_image nella catena anche se la slate non è ancora su disco.
+    # Usato da CoverSlateEnsurer per sapere cosa generare al go-live.
+    def pending_cover_record
+      return nil unless @entitlements.can_use_custom_cover?
+
+      candidates.each do |record, _source|
+        return record if record.cover_image.attached?
+      end
+      nil
+    end
+
+    def default_cover_url
+      DEFAULT_COVER_URL
+    end
+
+    def default_slate_path
+      ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
+    end
+
+    private
+
+    def candidates
+      [
+        [@match, "match"],
+        [@team, "team"],
+        [@club, "club"]
+      ]
+    end
+
+    def blob_path(attachment)
+      Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+    end
+  end
+end

backend/app/services/streams/cover_slate_ensurer.rb

@@ -0,0 +1,39 @@
+module Streams
+  # Garantisce che la slate MP4 esista per il record effettivo della partita (sync al go-live).
+  class CoverSlateEnsurer
+    def self.ensure_for!(match)
+      new(match).ensure!
+    end
+
+    def initialize(match)
+      @match = match
+      @resolver = CoverResolver.new(match)
+    end
+
+    def ensure!
+      record = find_pending_cover_record
+      return unless record
+      return if slate_ready?(record)
+
+      GenerateCoverSlate.call(record)
+    rescue GenerateCoverSlate::Error => e
+      Rails.logger.warn("[CoverSlateEnsurer] match=#{@match.id} #{e.message}")
+      nil
+    end
+
+    private
+
+    # Cerca il record con cover_image nella catena di ereditarietà,
+    # anche se la slate non è ancora pronta (a differenza di resolve che richiede la slate su disco).
+    def find_pending_cover_record
+      @resolver.pending_cover_record
+    end
+
+    def slate_ready?(record)
+      return false unless record.cover_slate.attached?
+
+      path = CoverSlatePaths.local_path_for(record)
+      path.present? && File.exist?(path)
+    end
+  end
+end

backend/app/services/streams/cover_slate_paths.rb

@@ -0,0 +1,35 @@
+module Streams
+  class CoverSlatePaths
+    def self.slates_custom_root
+      ENV.fetch("MEDIAMTX_SLATES_CUSTOM_DIR", "/slates/custom")
+    end
+
+    # ActiveStorage checksum is base64 e può contenere "/", "+", "=" — non usabile come path.
+    def self.safe_digest(checksum)
+      checksum.to_s.tr("+/", "-_").delete("=")
+    end
+
+    def self.filename_for(record)
+      return nil unless record.cover_slate.attached?
+
+      digest = safe_digest(record.cover_slate.blob.checksum)
+      prefix = record.class.name.underscore
+      "#{prefix}-#{record.id}-#{digest}.mp4"
+    end
+
+    def self.expected_path(record)
+      name = filename_for(record)
+      return nil if name.blank?
+
+      File.join(slates_custom_root, name)
+    end
+
+    def self.local_path_for(record)
+      path = expected_path(record)
+      return nil if path.blank?
+      return path if File.exist?(path)
+
+      nil
+    end
+  end
+end

backend/app/services/streams/generate_cover_slate.rb

@@ -0,0 +1,121 @@
+require "open3"
+
+module Streams
+  # Converte cover_image in MP4 slate (H.264 720p + AAC mono), allineato a infra/scripts/generate_slate.sh.
+  class GenerateCoverSlate
+    class Error < StandardError; end
+
+    SLATE_DURATION_SECS = 30
+    VIDEO_FILTER = "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=0x0a0a0e".freeze
+
+    def self.call(record)
+      new(record).call
+    end
+
+    def initialize(record)
+      @record = record
+    end
+
+    def call
+      return @record unless @record.cover_image.attached?
+
+      @image_temp = download_cover_image
+      @mp4_temp = encode_slate(@image_temp)
+      attach_slate(@mp4_temp)
+      write_to_slates_dir(@mp4_temp)
+      @record
+    rescue Error
+      raise
+    rescue StandardError => e
+      raise Error, e.message
+    ensure
+      cleanup_tempfiles
+    end
+
+    private
+
+    def download_cover_image
+      ext = extension_for(@record.cover_image.content_type)
+      path = temp_path("cover-in", ext)
+      @record.cover_image.blob.open(tmpdir: Dir.tmpdir) do |file|
+        FileUtils.cp(file.path, path)
+      end
+      path
+    end
+
+    def encode_slate(image_path)
+      out = temp_path("cover-slate", ".mp4")
+      cmd = ffmpeg_args(image_path, out)
+      stdout, stderr, status = Open3.capture3(*cmd)
+      unless status.success? && File.exist?(out) && File.size(out).positive?
+        detail = stderr.to_s.strip.presence || stdout.to_s.strip
+        raise Error, "ffmpeg slate failed: #{detail}"
+      end
+
+      out
+    end
+
+    def ffmpeg_args(input, output)
+      [
+        "ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
+        "-loop", "1", "-framerate", "30", "-i", input,
+        "-f", "lavfi", "-i", "anullsrc=r=48000:cl=mono",
+        "-filter:v", VIDEO_FILTER,
+        "-map", "0:v", "-map", "1:a",
+        "-t", SLATE_DURATION_SECS.to_s,
+        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-profile:v", "baseline", "-level", "3.1",
+        "-x264-params", "keyint=30:min-keyint=30:scenecut=0:bframes=0",
+        "-g", "30", "-keyint_min", "30", "-force_key_frames", "expr:gte(t,n_forced*1)",
+        "-preset", "fast",
+        "-c:a", "aac", "-b:a", "128k", "-ac", "1", "-shortest", "-y", output
+      ]
+    end
+
+    def attach_slate(mp4_path)
+      @record.cover_slate.purge if @record.cover_slate.attached?
+      File.open(mp4_path, "rb") do |io|
+        @record.cover_slate.attach(
+          io: io,
+          filename: slate_filename,
+          content_type: "video/mp4"
+        )
+      end
+      @record.reload
+    end
+
+    def write_to_slates_dir(mp4_path)
+      dest = CoverSlatePaths.expected_path(@record)
+      return unless dest
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      FileUtils.cp(mp4_path, dest)
+    rescue Errno::EACCES, Errno::EROFS => e
+      Rails.logger.info("[GenerateCoverSlate] skip disk copy #{dest}: #{e.class}")
+    end
+
+    def slate_filename
+      "#{@record.class.name.underscore}-#{@record.id}.mp4"
+    end
+
+    def extension_for(content_type)
+      case content_type
+      when "image/png" then ".png"
+      when "image/webp" then ".webp"
+      else ".jpg"
+      end
+    end
+
+    def temp_path(prefix, ext)
+      path = File.join(Dir.tmpdir, "#{prefix}-#{@record.class.name}-#{@record.id}-#{SecureRandom.hex(4)}#{ext}")
+      @tempfiles ||= []
+      @tempfiles << path
+      path
+    end
+
+    def cleanup_tempfiles
+      Array(@tempfiles).each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+  end
+end

backend/app/services/streams/ingest_unavailable_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Streams
+  # Ingest MediaMTX non raggiungibile (es. CPX ancora in bootstrap). API → 503 retryable.
+  class IngestUnavailableError < StandardError
+    attr_reader :code
+
+    def initialize(message = "Ingest temporaneamente non disponibile", code: "stream_ingest_unavailable")
+      super(message)
+      @code = code
+    end
+  end
+end

backend/app/services/streams/node_health.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Streams
+  # Probe reachability of MediaMTX API on a stream node (:9997).
+  class NodeHealth
+    def self.mediamtx_up?(node, timeout: 2)
+      new(node, timeout: timeout).mediamtx_up?
+    end
+
+    def self.promote_if_healthy!(node, timeout: 2)
+      return false unless node.status == "provisioning"
+      return false unless mediamtx_up?(node, timeout: timeout)
+
+      node.update!(status: "ready", last_health_at: Time.current)
+      true
+    end
+
+    def initialize(node, timeout: 2)
+      @node = node
+      @timeout = timeout
+    end
+
+    def mediamtx_up?
+      Mediamtx::Client.new(base_url: @node.api_base_url).reachable?(timeout: @timeout)
+    end
+  end
+end

backend/app/services/streams/node_provisioner.rb

@@ -80,11 +80,15 @@ module Streams
       urls = urls_for_node(role: role, home: home, hostname: hostname, simulated: simulated,
                            private_ip: private_ip, public_ip: ip, use_node_hostname: use_node_hostname)
 
-      StreamNode.create!(
+      # Simulated/lab che riusa MediaMTX home: subito ready. Cloud reale: provisioning
+      # finché :9997 risponde (evita allocate → Faraday Connection refused → 500).
+      initial_status = simulated ? "ready" : "provisioning"
+
+      node = StreamNode.create!(
         slug: slug,
         hostname: hostname,
         role: role,
-        status: "ready",
+        status: initial_status,
         provider: provider_name_for(cloud, role: role),
         provider_instance_id: instance.id,
         rtmp_base_url: urls.fetch(:rtmp_base_url),
@@ -102,6 +106,34 @@ module Streams
           "cloud_raw" => instance.raw
         }
       )
+
+      wait_until_mediamtx_ready!(node) unless simulated
+      node.reload
+    end
+
+    def wait_until_mediamtx_ready!(node, timeout: nil, interval: nil)
+      timeout ||= ENV.fetch("STREAM_NODE_READY_TIMEOUT_SECS", "180").to_i
+      interval ||= ENV.fetch("STREAM_NODE_READY_POLL_SECS", "3").to_f
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+      loop do
+        if Streams::NodeHealth.promote_if_healthy!(node)
+          Rails.logger.info("[Streams::NodeProvisioner] #{node.slug} MediaMTX ready")
+          return node
+        end
+
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if remaining <= 0
+          Rails.logger.warn(
+            "[Streams::NodeProvisioner] #{node.slug} ancora provisioning dopo #{timeout}s " \
+            "(api=#{node.api_base_url}); autoscaler continuerà a promuovere"
+          )
+          return node
+        end
+
+        sleep([interval, remaining].min)
+        node.reload
+      end
     end
 
     def urls_for_node(role:, home:, hostname:, simulated:, private_ip:, public_ip: nil, use_node_hostname:)

backend/app/services/streams/slate_distributor.rb

@@ -0,0 +1,105 @@
+module Streams
+  # Assicura che la slate MP4 custom sia sul nodo assegnato (home/lab locale, CPX via agent).
+  class SlateDistributor
+    class Error < StandardError; end
+
+    def self.slate_path_for_session(session)
+      new(session).mediamtx_slate_path
+    end
+
+    def self.ensure_for!(session)
+      new(session).ensure!
+    end
+
+    def initialize(session)
+      @session = session
+      @match = session.match
+      @node = session.stream_node
+      @resolver = CoverResolver.new(@match)
+    end
+
+    def mediamtx_slate_path
+      ensure! unless defined?(@mediamtx_path)
+      @mediamtx_path
+    end
+
+    def ensure!
+      result = @resolver.resolve
+      unless result
+        @mediamtx_path = default_slate_path
+        return @mediamtx_path
+      end
+
+      host_path = result.slate_local_path
+      filename = CoverSlatePaths.filename_for(result.record)
+      raise Error, "slate filename missing" if filename.blank?
+
+      # Path completo (non File.basename): il checksum AS può contenere "/" e spezzerebbe il path.
+      mediamtx_path = CoverSlatePaths.expected_path(result.record)
+
+      if cloud_node?
+        push_to_agent!(filename, result.record, host_path)
+      else
+        verify_local_slate!(host_path)
+      end
+
+      @mediamtx_path = mediamtx_path
+    rescue StandardError => e
+      # Agent cloud down / timeout / disk missing: non bloccare il go-live, usa slate default.
+      Rails.logger.warn("[SlateDistributor] session=#{@session.id} #{e.class}: #{e.message}")
+      @mediamtx_path = default_slate_path
+    end
+
+    private
+
+    def cloud_node?
+      @node&.role == "cloud" && agent_url.present?
+    end
+
+    def agent_url
+      ENV["STREAM_NODE_RELAY_AGENT_URL"].presence || @node&.relay_agent_url
+    end
+
+    def agent_secret
+      ENV["STREAM_NODE_AGENT_SECRET"].presence || "mediamtx_webhook_dev_secret"
+    end
+
+    def push_to_agent!(filename, record, host_path)
+      bytes = read_slate_bytes(record, host_path)
+      raise Error, "slate bytes missing for #{filename}" if bytes.blank?
+
+      uri = URI.parse("#{agent_url.chomp('/')}/slates/#{CGI.escape(filename)}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = 120
+      req = Net::HTTP::Put.new(uri)
+      req["Authorization"] = "Bearer #{agent_secret}" if agent_secret.present?
+      req["Content-Type"] = "video/mp4"
+      req.body = bytes
+      res = http.request(req)
+      return if res.is_a?(Net::HTTPSuccess)
+
+      raise Error, "agent PUT /slates/#{filename} HTTP #{res.code} #{res.body.to_s.truncate(200)}"
+    end
+
+    def read_slate_bytes(record, host_path)
+      return File.binread(host_path) if host_path.present? && File.exist?(host_path)
+
+      return unless record.cover_slate.attached?
+
+      record.cover_slate.blob.open(tmpdir: Dir.tmpdir) do |file|
+        return File.binread(file.path)
+      end
+    end
+
+    def verify_local_slate!(host_path)
+      return if host_path.present? && File.exist?(host_path)
+
+      raise Error, "slate missing on disk: #{host_path}"
+    end
+
+    def default_slate_path
+      ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
+    end
+  end
+end

backend/app/services/teams/entitlements.rb

@@ -35,6 +35,20 @@ module Teams
       active? && plan.phone_download_enabled?
     end
 
+    def can_use_custom_cover?
+      premium_full? && plan.custom_cover_enabled?
+    end
+
+    def assert_can_upload_cover!
+      unless can_use_custom_cover?
+        raise EntitlementError.new(
+          "La copertina sponsor personalizzata richiede Premium Full",
+          code: "premium_full_required",
+          billing_url: billing_url
+        )
+      end
+    end
+
     def max_staff_transmission
       plan.max_staff_transmission
     end
@@ -225,7 +239,8 @@ module Teams
         recording_retention_days: recording_retention_days,
         phone_download_enabled: phone_download_enabled?,
         youtube_enabled: youtube_enabled?,
-        youtube_mode: plan.youtube_mode
+        youtube_mode: plan.youtube_mode,
+        custom_cover_enabled: can_use_custom_cover?
       }
     end
 

backend/app/services/youtube/broadcast_service.rb

@@ -97,6 +97,24 @@ module Youtube
       :skipped
     end
 
+    def enable_video_embed!(video_id, privacy_status: "unlisted")
+      return if video_id.blank? || video_id.to_s.start_with?("mock_")
+      return if @credential.blank? || missing_oauth_config?
+
+      client = authorized_client
+      video = Google::Apis::YoutubeV3::Video.new(
+        id: video_id,
+        status: Google::Apis::YoutubeV3::VideoStatus.new(
+          embeddable: true,
+          privacy_status: privacy_status.presence || "unlisted",
+          self_declared_made_for_kids: false
+        )
+      )
+      client.update_video("status", video)
+    rescue Google::Apis::Error => e
+      raise Error, e.message
+    end
+
     def complete_broadcast!(broadcast_id)
       return if broadcast_id.blank?
       return if @credential.blank? || missing_oauth_config?

backend/app/services/youtube/vod_status.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Youtube
+  # Stato VOD dopo una live (broadcast_id ≈ video_id su YouTube).
+  class VodStatus
+    class Error < StandardError; end
+
+    Result = Struct.new(
+      :ready,
+      :video_id,
+      :title,
+      :duration_secs,
+      :thumbnail_url,
+      :privacy_status,
+      :upload_status,
+      :embeddable,
+      keyword_init: true
+    )
+
+    def initialize(team, channel: "team")
+      @team = team
+      @channel = channel
+    end
+
+    def fetch(video_id)
+      raise Error, "video_id mancante" if video_id.blank?
+
+      if mock_or_unconfigured?(video_id)
+        return Result.new(
+          ready: true,
+          video_id: video_id,
+          title: nil,
+          duration_secs: nil,
+          thumbnail_url: nil,
+          privacy_status: "unlisted",
+          upload_status: "processed",
+          embeddable: true
+        )
+      end
+
+      client = authorized_client
+      item = client.list_videos("snippet,contentDetails,status", id: video_id).items&.first
+      return Result.new(ready: false, video_id: video_id) if item.blank?
+
+      upload_status = item.status&.upload_status.to_s
+      ready = upload_status.in?(%w[processed uploaded]) ||
+              (item.snippet.present? && upload_status != "deleted" && upload_status != "rejected" && upload_status != "failed")
+
+      Result.new(
+        ready: ready,
+        video_id: item.id,
+        title: item.snippet&.title,
+        duration_secs: parse_duration(item.content_details&.duration),
+        thumbnail_url: item.snippet&.thumbnails&.high&.url || item.snippet&.thumbnails&.default&.url,
+        privacy_status: item.status&.privacy_status,
+        upload_status: upload_status,
+        embeddable: item.status&.embeddable != false
+      )
+    rescue Google::Apis::Error => e
+      raise Error, e.message
+    end
+
+    private
+
+    def mock_or_unconfigured?(video_id)
+      video_id.to_s.start_with?("mock_") ||
+        ENV["YOUTUBE_CLIENT_ID"].blank? ||
+        CredentialResolver.new(@team, channel: @channel).resolve.blank?
+    end
+
+    def authorized_client
+      credential = CredentialResolver.new(@team, channel: @channel).resolve
+      raise Error, "Credenziali YouTube non disponibili" if credential.blank?
+
+      OauthRefresh.new(credential).apply!(Google::Apis::YoutubeV3::YouTubeService.new)
+    end
+
+    def parse_duration(iso)
+      return nil if iso.blank?
+
+      # PT1H2M3S
+      match = iso.match(/\APT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?\z/)
+      return nil unless match
+
+      match[1].to_i * 3600 + match[2].to_i * 60 + match[3].to_i
+    end
+  end
+end

backend/app/views/admin/analytics/index.html.erb

@@ -0,0 +1,72 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.analytics.index.title") %></h2>
+  <p class="muted admin-page-sub"><%= t("admin.analytics.index.lead") %></p>
+</div>
+
+<div class="panel admin-sessions-filters">
+  <%= form_with url: admin_analytics_path, method: :get, local: true, class: "admin-filter-form" do %>
+    <div class="admin-filter-grid">
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.from") %></span>
+        <%= date_field_tag :from, @filters[:from] %>
+      </label>
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.to") %></span>
+        <%= date_field_tag :to, @filters[:to] %>
+      </label>
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.device") %></span>
+        <%= select_tag :device,
+              options_for_select(
+                [[t("admin.analytics.filters.any"), ""]] + AnalyticsEvent::DEVICES.map { |d| [d, d] },
+                @filters[:device]
+              ) %>
+      </label>
+    </div>
+    <div class="admin-filter-actions">
+      <%= submit_tag t("admin.analytics.filters.apply"), class: "admin-btn admin-btn--primary admin-btn--sm" %>
+      <%= link_to t("admin.analytics.filters.reset"), admin_analytics_path, class: "admin-btn admin-btn--outline admin-btn--sm" %>
+    </div>
+  <% end %>
+</div>
+
+<div class="panel">
+  <% if @pages.any? %>
+    <div class="admin-table-wrap">
+      <table class="admin-table">
+        <thead>
+          <tr>
+            <th><%= t("admin.analytics.index.table.path") %></th>
+            <th><%= t("admin.analytics.index.table.pageviews") %></th>
+            <th><%= t("admin.analytics.index.table.moves") %></th>
+            <th><%= t("admin.analytics.index.table.clicks") %></th>
+            <th><%= t("admin.analytics.index.table.avg_scroll") %></th>
+            <th><%= t("admin.analytics.index.table.max_scroll") %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @pages.each do |row| %>
+            <% avg = row[:scroll_samples].positive? ? (row[:scroll_sum].to_f / row[:scroll_samples]).round : 0 %>
+            <tr>
+              <td><code class="admin-mono"><%= row[:page_path] %></code></td>
+              <td><%= row[:pageviews] %></td>
+              <td><%= row[:moves] %></td>
+              <td><%= row[:clicks] %></td>
+              <td class="muted"><%= avg %>%</td>
+              <td class="muted"><%= row[:max_scroll] %>%</td>
+              <td>
+                <%= link_to t("admin.analytics.index.heatmap"),
+                      admin_analytics_page_path(page_path: row[:page_path], from: @filters[:from], to: @filters[:to], device: @filters[:device]) %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  <% else %>
+    <p class="empty"><%= t("admin.analytics.index.none") %></p>
+  <% end %>
+</div>

backend/app/views/admin/analytics/show.html.erb

@@ -0,0 +1,138 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head admin-session-head">
+  <div>
+    <p class="muted admin-page-sub">
+      <%= link_to t("admin.analytics.show.back"), admin_analytics_path(from: @filters[:from], to: @filters[:to], device: @filters[:device]) %>
+    </p>
+    <h2 class="admin-page-title"><%= t("admin.analytics.show.title") %></h2>
+    <p><code class="admin-mono"><%= @page_path %></code></p>
+  </div>
+</div>
+
+<div class="panel admin-sessions-filters">
+  <%= form_with url: admin_analytics_page_path, method: :get, local: true, class: "admin-filter-form" do %>
+    <%= hidden_field_tag :page_path, @page_path %>
+    <div class="admin-filter-grid">
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.from") %></span>
+        <%= date_field_tag :from, @filters[:from] %>
+      </label>
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.to") %></span>
+        <%= date_field_tag :to, @filters[:to] %>
+      </label>
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.device") %></span>
+        <%= select_tag :device,
+              options_for_select(
+                [[t("admin.analytics.filters.any"), ""]] + AnalyticsEvent::DEVICES.map { |d| [d, d] },
+                @filters[:device]
+              ) %>
+      </label>
+      <label class="admin-filter-field">
+        <span><%= t("admin.analytics.filters.layer") %></span>
+        <%= select_tag :layer,
+              options_for_select(
+                [
+                  [t("admin.analytics.filters.layer_move"), "move"],
+                  [t("admin.analytics.filters.layer_click"), "click"]
+                ],
+                @filters[:layer]
+              ) %>
+      </label>
+    </div>
+    <div class="admin-filter-actions">
+      <%= submit_tag t("admin.analytics.filters.apply"), class: "admin-btn admin-btn--primary admin-btn--sm" %>
+    </div>
+  <% end %>
+</div>
+
+<div class="admin-session-grid">
+  <section class="panel">
+    <h3><%= t("admin.analytics.show.summary") %></h3>
+    <dl class="admin-kv">
+      <div>
+        <dt><%= t("admin.analytics.index.table.pageviews") %></dt>
+        <dd><%= @pageviews %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.analytics.index.table.moves") %></dt>
+        <dd><%= @move_total %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.analytics.index.table.clicks") %></dt>
+        <dd><%= @click_total %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.analytics.index.table.avg_scroll") %></dt>
+        <dd><%= @avg_scroll %>%</dd>
+      </div>
+      <div>
+        <dt><%= t("admin.analytics.index.table.max_scroll") %></dt>
+        <dd><%= @max_scroll %>%</dd>
+      </div>
+    </dl>
+  </section>
+
+  <section class="panel" style="grid-column: span 2;">
+    <h3><%= t("admin.analytics.show.scroll_depth") %></h3>
+    <div class="admin-scroll-bar" aria-hidden="true">
+      <div class="admin-scroll-bar__avg" style="width: <%= @avg_scroll %>%"></div>
+      <div class="admin-scroll-bar__max" style="left: <%= @max_scroll %>%"></div>
+    </div>
+    <p class="muted admin-table-sub">
+      <%= t("admin.analytics.show.scroll_hint", avg: @avg_scroll, max: @max_scroll) %>
+    </p>
+  </section>
+</div>
+
+<section class="panel">
+  <h3>
+    <%= @filters[:layer] == "click" ? t("admin.analytics.show.heatmap_clicks") : t("admin.analytics.show.heatmap_moves") %>
+  </h3>
+  <p class="muted admin-table-sub"><%= t("admin.analytics.show.heatmap_hint") %></p>
+
+  <% if @cells.any? %>
+    <div class="admin-heatmap-stage" id="admin-heatmap-stage">
+      <% if @snapshot&.image&.attached? %>
+        <div
+          class="admin-heatmap-scaler"
+          id="admin-heatmap-scaler"
+          data-design-width="<%= [@snapshot.width, 1].max %>"
+          data-design-height="<%= [@snapshot.height, 1].max %>"
+        >
+          <%= image_tag url_for(@snapshot.image),
+                class: "admin-heatmap-shot",
+                id: "admin-heatmap-shot",
+                alt: t("admin.analytics.show.preview_title") %>
+          <canvas
+            id="admin-heatmap"
+            class="admin-heatmap-overlay"
+            data-grid="<%= @grid %>"
+            data-max="<%= [@max_weight, 1].max %>"
+            data-cells="<%= @cells.map { |(x, y), c| { x: x, y: y, c: c } }.to_json %>"
+          ></canvas>
+        </div>
+        <p class="muted admin-table-sub" style="margin: 0.75rem 1rem 1rem;">
+          <%= t("admin.analytics.show.snapshot_meta",
+                device: @snapshot.device,
+                at: l(@snapshot.captured_at, format: :short)) %>
+        </p>
+      <% else %>
+        <div class="admin-heatmap-fallback" aria-hidden="true"></div>
+        <p class="muted admin-heatmap-fallback-note"><%= t("admin.analytics.show.snapshot_missing") %></p>
+        <canvas
+          id="admin-heatmap"
+          class="admin-heatmap-overlay"
+          data-grid="<%= @grid %>"
+          data-max="<%= [@max_weight, 1].max %>"
+          data-cells="<%= @cells.map { |(x, y), c| { x: x, y: y, c: c } }.to_json %>"
+        ></canvas>
+      <% end %>
+    </div>
+    <script src="/admin-analytics-heatmap.js?v=4" defer></script>
+  <% else %>
+    <p class="empty"><%= t("admin.analytics.show.no_points") %></p>
+  <% end %>
+</section>

backend/app/views/admin/announcements/_form.html.erb

@@ -0,0 +1,112 @@
+<%= form_with model: announcement, url: (announcement.persisted? ? admin_announcement_path(announcement) : admin_announcements_path),
+      method: (announcement.persisted? ? :patch : :post), local: true, class: "admin-form" do |f| %>
+  <div class="admin-form-row">
+    <div>
+      <%= f.label :kind, t("admin.announcements.form.kind") %>
+      <%= f.select :kind, AppAnnouncement::KINDS.map { |k| [t("admin.announcements.kind.#{k}"), k] } %>
+    </div>
+    <div>
+      <%= f.label :severity, t("admin.announcements.form.severity") %>
+      <%= f.select :severity, AppAnnouncement::SEVERITIES.map { |k| [t("admin.announcements.severity.#{k}"), k] } %>
+    </div>
+  </div>
+
+  <div>
+    <%= f.label :status, t("admin.announcements.form.status") %>
+    <%= f.select :status, AppAnnouncement::STATUSES.map { |k| [t("admin.announcements.status.#{k}"), k] } %>
+  </div>
+
+  <fieldset class="admin-channels">
+    <legend><%= t("admin.announcements.form.channels") %></legend>
+    <label class="admin-checkbox">
+      <%= f.check_box :show_on_android %>
+      <span><%= t("admin.announcements.channels.android") %></span>
+    </label>
+    <label class="admin-checkbox">
+      <%= f.check_box :show_on_ios %>
+      <span><%= t("admin.announcements.channels.ios") %></span>
+    </label>
+    <label class="admin-checkbox">
+      <%= f.check_box :show_on_web_public %>
+      <span><%= t("admin.announcements.channels.web_public") %></span>
+    </label>
+    <label class="admin-checkbox">
+      <%= f.check_box :show_on_web_private %>
+      <span><%= t("admin.announcements.channels.web_private") %></span>
+    </label>
+    <p class="muted admin-form-hint"><%= t("admin.announcements.form.channels_hint") %></p>
+  </fieldset>
+
+  <fieldset class="admin-channels">
+    <legend><%= t("admin.announcements.form.locales_legend") %></legend>
+    <p class="muted admin-form-hint"><%= t("admin.announcements.form.locales_hint") %></p>
+    <div class="admin-locale-tabs" role="tablist">
+      <% language_options.each do |opt| %>
+        <button type="button"
+                class="admin-locale-tab<%= " is-active" if opt[:code].to_s == I18n.default_locale.to_s %>"
+                data-locale-tab="<%= opt[:code] %>"
+                role="tab"
+                aria-selected="<%= opt[:code].to_s == I18n.default_locale.to_s %>">
+          <span aria-hidden="true"><%= opt[:flag] %></span>
+          <%= opt[:native] %>
+          <% if opt[:code].to_s == I18n.default_locale.to_s %>
+            <span class="muted">(<%= t("admin.announcements.form.locale_required") %>)</span>
+          <% elsif announcement.filled_locale_codes.include?(opt[:code].to_s) %>
+            <span class="muted">✓</span>
+          <% end %>
+        </button>
+      <% end %>
+    </div>
+    <% language_options.each do |opt| %>
+      <div class="admin-locale-panel"
+           data-locale-panel="<%= opt[:code] %>"
+           role="tabpanel"
+           <%= "hidden" unless opt[:code].to_s == I18n.default_locale.to_s %>>
+        <%= render "locale_copy", f: f, announcement: announcement, locale: opt[:code] %>
+      </div>
+    <% end %>
+  </fieldset>
+
+  <div class="admin-form-row">
+    <div>
+      <%= f.label :starts_at, t("admin.announcements.form.starts_at") %>
+      <%= f.datetime_field :starts_at, value: announcement.starts_at&.in_time_zone&.strftime("%Y-%m-%dT%H:%M") %>
+    </div>
+    <div>
+      <%= f.label :ends_at, t("admin.announcements.form.ends_at") %>
+      <%= f.datetime_field :ends_at, value: announcement.ends_at&.in_time_zone&.strftime("%Y-%m-%dT%H:%M") %>
+    </div>
+  </div>
+  <p class="muted admin-form-hint"><%= t("admin.announcements.form.window_hint") %></p>
+
+  <label class="admin-checkbox">
+    <%= f.check_box :dismissible %>
+    <span><%= t("admin.announcements.form.dismissible") %></span>
+  </label>
+  <p class="muted admin-form-hint"><%= t("admin.announcements.form.dismissible_hint") %></p>
+
+  <div class="admin-form-actions">
+    <%= f.submit (announcement.persisted? ? t("admin.announcements.form.submit_update") : t("admin.announcements.form.submit_create")), class: "admin-btn admin-btn--primary" %>
+    <%= link_to t("admin.announcements.form.cancel"), admin_announcements_path, class: "admin-btn admin-btn--outline" %>
+  </div>
+<% end %>
+
+<script>
+  (function () {
+    var tabs = document.querySelectorAll("[data-locale-tab]");
+    if (!tabs.length) return;
+    tabs.forEach(function (btn) {
+      btn.addEventListener("click", function () {
+        var loc = btn.getAttribute("data-locale-tab");
+        tabs.forEach(function (other) {
+          var on = other === btn;
+          other.classList.toggle("is-active", on);
+          other.setAttribute("aria-selected", on ? "true" : "false");
+        });
+        document.querySelectorAll("[data-locale-panel]").forEach(function (panel) {
+          panel.hidden = panel.getAttribute("data-locale-panel") !== loc;
+        });
+      });
+    });
+  })();
+</script>

backend/app/views/admin/announcements/_locale_copy.html.erb

@@ -0,0 +1,44 @@
+<% it = locale.to_s == I18n.default_locale.to_s %>
+<% values = announcement.copy_values_for(locale) %>
+<% name_base = "app_announcement[translations][#{locale}]" %>
+
+<div>
+  <% if it %>
+    <%= f.label :title, t("admin.announcements.form.title") %>
+    <%= f.text_field :title, required: true, maxlength: 120, id: "ann_#{locale}_title" %>
+  <% else %>
+    <label for="ann_<%= locale %>_title"><%= t("admin.announcements.form.title") %></label>
+    <%= text_field_tag "#{name_base}[title]", values["title"], maxlength: 120, id: "ann_#{locale}_title" %>
+  <% end %>
+</div>
+
+<div>
+  <% if it %>
+    <%= f.label :body, t("admin.announcements.form.body") %>
+    <%= f.text_area :body, required: true, rows: 5, maxlength: 2000, id: "ann_#{locale}_body" %>
+  <% else %>
+    <label for="ann_<%= locale %>_body"><%= t("admin.announcements.form.body") %></label>
+    <%= text_area_tag "#{name_base}[body]", values["body"], rows: 5, maxlength: 2000, id: "ann_#{locale}_body" %>
+  <% end %>
+</div>
+
+<div>
+  <% if it %>
+    <%= f.label :action_url, t("admin.announcements.form.action_url") %>
+    <%= f.url_field :action_url, placeholder: "https://", id: "ann_#{locale}_action_url" %>
+  <% else %>
+    <label for="ann_<%= locale %>_action_url"><%= t("admin.announcements.form.action_url") %></label>
+    <%= url_field_tag "#{name_base}[action_url]", values["action_url"], placeholder: "https://", id: "ann_#{locale}_action_url" %>
+  <% end %>
+</div>
+<p class="muted admin-form-hint"><%= t("admin.announcements.form.action_url_hint") %></p>
+
+<div>
+  <% if it %>
+    <%= f.label :action_label, t("admin.announcements.form.action_label") %>
+    <%= f.text_field :action_label, maxlength: 40, id: "ann_#{locale}_action_label" %>
+  <% else %>
+    <label for="ann_<%= locale %>_action_label"><%= t("admin.announcements.form.action_label") %></label>
+    <%= text_field_tag "#{name_base}[action_label]", values["action_label"], maxlength: 40, id: "ann_#{locale}_action_label" %>
+  <% end %>
+</div>

backend/app/views/admin/announcements/edit.html.erb

@@ -0,0 +1,9 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.announcements.edit.title") %></h2>
+</div>
+
+<div class="panel">
+  <%= render "form", announcement: @announcement %>
+</div>

backend/app/views/admin/announcements/index.html.erb

@@ -0,0 +1,57 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.announcements.index.title") %></h2>
+  <p class="muted admin-page-sub"><%= t("admin.announcements.index.lead") %></p>
+</div>
+
+<div class="panel" style="margin-bottom:1.5rem">
+  <div class="admin-toolbar">
+    <%= link_to t("admin.announcements.index.new"), new_admin_announcement_path, class: "admin-btn admin-btn--primary" %>
+  </div>
+</div>
+
+<div class="panel">
+  <h2><%= t("admin.announcements.index.table_title") %></h2>
+  <% if @announcements.any? %>
+    <div class="admin-table-wrap">
+      <table class="admin-table">
+        <thead>
+          <tr>
+            <th><%= t("admin.announcements.table.status") %></th>
+            <th><%= t("admin.announcements.table.kind") %></th>
+            <th><%= t("admin.announcements.table.title") %></th>
+            <th><%= t("admin.announcements.table.channels") %></th>
+            <th><%= t("admin.announcements.table.window") %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @announcements.each do |item| %>
+            <tr>
+              <td>
+                <span class="badge badge--<%= announcement_status_badge(item) %>"><%= t("admin.announcements.status.#{item.status}") %></span>
+              </td>
+              <td class="muted"><%= t("admin.announcements.kind.#{item.kind}") %></td>
+              <td>
+                <strong><%= item.title %></strong>
+                <div class="muted" style="font-size:0.85rem;margin-top:0.25rem"><%= truncate(item.body, length: 90) %></div>
+                <div class="muted" style="font-size:0.8rem;margin-top:0.2rem"><%= item.filled_locale_codes.map(&:upcase).join(" · ") %></div>
+              </td>
+              <td class="muted"><%= announcement_channels_label(item) %></td>
+              <td class="muted"><%= announcement_window_label(item) %></td>
+              <td class="admin-actions">
+                <%= link_to t("admin.announcements.actions.edit"), edit_admin_announcement_path(item), class: "admin-btn admin-btn--sm" %>
+                <%= button_to t("admin.announcements.actions.delete"), admin_announcement_path(item), method: :delete,
+                      class: "admin-btn admin-btn--sm admin-btn--danger",
+                      form: { data: { confirm: t("admin.announcements.actions.delete_confirm") } } %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  <% else %>
+    <p class="empty"><%= t("admin.announcements.index.none") %></p>
+  <% end %>
+</div>

backend/app/views/admin/announcements/new.html.erb

@@ -0,0 +1,9 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.announcements.new.title") %></h2>
+</div>
+
+<div class="panel">
+  <%= render "form", announcement: @announcement %>
+</div>

backend/app/views/admin/dashboard/index.html.erb

@@ -107,6 +107,8 @@
           <tr>
             <th><%= t("admin.dashboard.sessions.table.match") %></th>
             <th><%= t("admin.dashboard.sessions.table.status") %></th>
+            <th><%= t("admin.dashboard.sessions.table.client") %></th>
+            <th><%= t("admin.dashboard.sessions.table.ingest") %></th>
             <th><%= t("admin.dashboard.sessions.table.start") %></th>
             <th><%= t("admin.dashboard.sessions.table.link") %></th>
             <th></th>
@@ -117,12 +119,16 @@
             <tr>
               <td><%= s.match.team.name %> vs <%= s.match.opponent_name %></td>
               <td><span class="badge badge--<%= s.status == 'live' ? 'live' : (s.status == 'paused' ? 'paused' : 'connecting') %>"><%= s.status %></span></td>
+              <td class="muted"><%= admin_session_client_summary(s) %></td>
+              <td><%= render "admin/sessions/ingest_cell", session: s %></td>
               <td class="muted"><%= s.started_at&.strftime("%d/%m %H:%M") || t("admin.common.dash") %></td>
-              <td class="admin-link-compact">
+              <td>
-                <% admin_session_watch_links(s).each do |link| %>
+                <div class="admin-link-compact">
-                  <%= link_to link[:label], link[:url], target: "_blank", rel: "noopener", class: "admin-link-chip" %>
+                  <% admin_session_watch_links(s).each do |link| %>
-                <% end %>
+                    <%= link_to link[:label], link[:url], target: "_blank", rel: "noopener", class: "admin-link-chip" %>
-                <%= link_to t("admin.dashboard.sessions.regia"), admin_session_path(s), class: "admin-link-chip admin-link-chip--regia" %>
+                  <% end %>
+                  <%= link_to t("admin.dashboard.sessions.regia"), admin_session_path(s), class: "admin-link-chip admin-link-chip--regia" %>
+                </div>
               </td>
               <td class="admin-actions">
                 <%= link_to t("admin.dashboard.sessions.detail"), admin_session_path(s) %>

backend/app/views/admin/sessions/_ingest_cell.html.erb

@@ -0,0 +1,12 @@
+<% slug = session.ingest_slug_display %>
+<% role = session.ingest_role_display %>
+<% if slug.present? %>
+  <div class="admin-ingest">
+    <code class="admin-ingest__slug"><%= slug %></code>
+    <% if role.present? %>
+      <span class="badge <%= admin_session_ingest_badge_class(role) %>"><%= admin_session_ingest_role_label(role) %></span>
+    <% end %>
+  </div>
+<% else %>
+  <span class="muted"><%= t("admin.sessions.ingest.none") %></span>
+<% end %>

backend/app/views/admin/sessions/index.html.erb

@@ -1,28 +1,133 @@
-<h2><%= t("admin.sessions.index.title") %></h2>
+<% content_for :body_class, "admin-body" %>
-  <table class="admin-table">
+
-  <thead>
+<div class="admin-page-head">
-    <tr>
+  <h2 class="admin-page-title"><%= t("admin.sessions.index.title") %></h2>
-      <th><%= t("admin.sessions.index.table.match") %></th>
+  <p class="muted admin-page-sub"><%= t("admin.sessions.index.lead") %></p>
-      <th><%= t("admin.sessions.index.table.status") %></th>
+</div>
-      <th><%= t("admin.sessions.index.table.disconnects") %></th>
+
-      <th><%= t("admin.sessions.index.table.link") %></th>
+<div class="panel admin-sessions-filters">
-      <th></th>
+  <%= form_with url: admin_sessions_path, method: :get, local: true, class: "admin-filter-form" do %>
-    </tr>
+    <div class="admin-filter-grid">
-  </thead>
+      <label class="admin-filter-field">
-  <tbody>
+        <span><%= t("admin.sessions.index.filters.q") %></span>
-    <% @sessions.each do |s| %>
+        <%= text_field_tag :q, @filters[:q], placeholder: t("admin.sessions.index.filters.q_placeholder") %>
-      <tr>
+      </label>
-        <td><%= s.match.team.name %> vs <%= s.match.opponent_name %></td>
+
-        <td><span class="badge <%= s.status == 'live' ? 'badge--live' : 'badge--paused' %>"><%= s.status %></span></td>
+      <label class="admin-filter-field">
-        <td><%= s.disconnection_count %></td>
+        <span><%= t("admin.sessions.index.filters.status") %></span>
-        <td class="admin-link-compact">
+        <%= select_tag :status,
-          <% admin_session_watch_links(s).each do |link| %>
+              options_for_select(
-            <%= link_to link[:label], link[:url], target: "_blank", rel: "noopener", class: "admin-link-chip" %>
+                [[t("admin.sessions.index.filters.any"), ""]] + StreamSession::STATUSES.map { |s| [s, s] },
+                @filters[:status]
+              ) %>
+      </label>
+
+      <label class="admin-filter-field">
+        <span><%= t("admin.sessions.index.filters.platform") %></span>
+        <%= select_tag :platform,
+              options_for_select(
+                [[t("admin.sessions.index.filters.any"), ""]] + StreamSession::LIVE_PLATFORMS.map { |p| [p, p] },
+                @filters[:platform]
+              ) %>
+      </label>
+
+      <label class="admin-filter-field">
+        <span><%= t("admin.sessions.index.filters.club") %></span>
+        <%= select_tag :club_id,
+              options_for_select(
+                [[t("admin.sessions.index.filters.any"), ""]] + @clubs.map { |c| [c.name, c.id] },
+                @filters[:club_id]
+              ) %>
+      </label>
+
+      <label class="admin-filter-field">
+        <span><%= t("admin.sessions.index.filters.node") %></span>
+        <%= select_tag :stream_node_id,
+              options_for_select(
+                [[t("admin.sessions.index.filters.any"), ""]] + @nodes.map { |n| ["#{n.slug} (#{n.role})", n.id] },
+                @filters[:stream_node_id]
+              ) %>
+      </label>
+
+      <label class="admin-filter-field">
+        <span><%= t("admin.sessions.index.filters.from") %></span>
+        <%= date_field_tag :from, @filters[:from] %>
+      </label>
+
+      <label class="admin-filter-field">
+        <span><%= t("admin.sessions.index.filters.to") %></span>
+        <%= date_field_tag :to, @filters[:to] %>
+      </label>
+    </div>
+
+    <div class="admin-filter-actions">
+      <%= submit_tag t("admin.sessions.index.filters.apply"), class: "admin-btn admin-btn--primary admin-btn--sm" %>
+      <%= link_to t("admin.sessions.index.filters.reset"), admin_sessions_path, class: "admin-btn admin-btn--outline admin-btn--sm" %>
+      <span class="muted admin-filter-count">
+        <%= t("admin.sessions.index.results", shown: @sessions.size, total: @total_count) %>
+      </span>
+    </div>
+  <% end %>
+</div>
+
+<div class="panel">
+  <% if @sessions.any? %>
+    <div class="admin-table-wrap">
+      <table class="admin-table admin-table--sessions">
+        <thead>
+          <tr>
+            <th><%= t("admin.sessions.index.table.club") %></th>
+            <th><%= t("admin.sessions.index.table.match") %></th>
+            <th><%= t("admin.sessions.index.table.status") %></th>
+            <th><%= t("admin.sessions.index.table.started") %></th>
+            <th><%= t("admin.sessions.index.table.ended") %></th>
+            <th><%= t("admin.sessions.index.table.duration") %></th>
+            <th><%= t("admin.sessions.index.table.ingest") %></th>
+            <th><%= t("admin.sessions.index.table.client") %></th>
+            <th><%= t("admin.sessions.index.table.disconnects") %></th>
+            <th><%= t("admin.sessions.index.table.link") %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @sessions.each do |s| %>
+            <% club = s.match.team.club %>
+            <tr>
+              <td>
+                <% if club %>
+                  <%= link_to club.name, admin_club_path(club), class: "admin-table-strong" %>
+                <% else %>
+                  <span class="muted"><%= t("admin.common.dash") %></span>
+                <% end %>
+              </td>
+              <td>
+                <div class="admin-table-strong"><%= s.match.team.name %> vs <%= s.match.opponent_name %></div>
+                <div class="muted admin-table-sub"><%= s.platform %></div>
+              </td>
+              <td>
+                <span class="badge <%= admin_session_status_badge_class(s.status) %>"><%= s.status %></span>
+              </td>
+              <td class="muted"><%= admin_datetime(s.started_at || s.created_at) %></td>
+              <td class="muted"><%= s.ended_at ? admin_datetime(s.ended_at) : t("admin.common.dash") %></td>
+              <td class="muted"><%= admin_session_duration_label(s) %></td>
+              <td><%= render "admin/sessions/ingest_cell", session: s %></td>
+              <td class="muted admin-table-sub"><%= admin_session_client_summary(s) %></td>
+              <td><%= s.disconnection_count %></td>
+              <td>
+                <div class="admin-link-compact">
+                  <% admin_session_watch_links(s).each do |link| %>
+                    <%= link_to link[:label], link[:url], target: "_blank", rel: "noopener", class: "admin-link-chip" %>
+                  <% end %>
+                  <%= link_to t("admin.sessions.index.regia"), admin_session_path(s), class: "admin-link-chip admin-link-chip--regia" %>
+                </div>
+              </td>
+              <td><%= link_to t("admin.sessions.index.detail"), admin_session_path(s) %></td>
+            </tr>
           <% end %>
-          <%= link_to t("admin.sessions.index.regia"), admin_session_path(s), class: "admin-link-chip admin-link-chip--regia" %>
+        </tbody>
-        </td>
+      </table>
-        <td><%= link_to t("admin.sessions.index.detail"), admin_session_path(s) %></td>
+    </div>
-      </tr>
+  <% else %>
-    <% end %>
+    <p class="empty"><%= t("admin.sessions.index.none") %></p>
-  </tbody>
+  <% end %>
-</table>
+</div>

backend/app/views/admin/sessions/show.html.erb

@@ -1,39 +1,287 @@
-<h2><%= t("admin.sessions.show.title", id: @session.id) %></h2>
+<% content_for :body_class, "admin-body" %>
-<p><%= t("admin.sessions.show.status_label") %> <strong><%= @session.status %></strong></p>
+<% team = @session.match.team %>
-<% unless @session.terminal? %>
+<% club = @club || team.club %>
-  <p>
+
-    <%= button_to t("admin.sessions.show.stop_button"),
+<div class="admin-page-head admin-session-head">
-          stop_admin_session_path(@session),
+  <div>
-          method: :post,
+    <p class="muted admin-page-sub">
-          class: "admin-btn admin-btn--danger",
+      <%= link_to t("admin.sessions.show.back"), admin_sessions_path %>
-          form: { data: { turbo_confirm: t("admin.sessions.show.stop_confirm") } } %>
+    </p>
-  </p>
+    <h2 class="admin-page-title"><%= t("admin.sessions.show.heading") %></h2>
-<% end %>
+    <p class="admin-session-match">
-<p><%= t("admin.sessions.show.match_label", team: @session.match.team.name, opponent: @session.match.opponent_name) %></p>
+      <strong><%= team.name %></strong>
+      <span class="muted">vs</span>
+      <strong><%= @session.match.opponent_name %></strong>
+    </p>
+    <% if club %>
+      <p class="muted">
+        <%= t("admin.sessions.show.club_label") %>
+        <%= link_to club.name, admin_club_path(club) %>
+      </p>
+    <% end %>
+  </div>
+  <div class="admin-session-head-actions">
+    <span class="badge <%= admin_session_status_badge_class(@session.status) %>"><%= @session.status %></span>
+    <% unless @session.terminal? %>
+      <%= button_to t("admin.sessions.show.stop_button"),
+            stop_admin_session_path(@session),
+            method: :post,
+            class: "admin-btn admin-btn--danger admin-btn--sm",
+            form: { data: { turbo_confirm: t("admin.sessions.show.stop_confirm") } } %>
+    <% end %>
+  </div>
+</div>
+
+<div class="admin-session-grid">
+  <section class="panel">
+    <h3><%= t("admin.sessions.show.summary_title") %></h3>
+    <dl class="admin-kv">
+      <div>
+        <dt><%= t("admin.sessions.show.fields.id") %></dt>
+        <dd><code class="admin-mono"><%= @session.id %></code></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.club") %></dt>
+        <dd><%= club&.name || t("admin.common.dash") %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.team") %></dt>
+        <dd><%= team.name %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.opponent") %></dt>
+        <dd><%= @session.match.opponent_name %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.operator") %></dt>
+        <dd>
+          <% if @session.user %>
+            <%= @session.user.name.presence || @session.user.email %>
+            <span class="muted">(<%= @session.user.email %>)</span>
+          <% else %>
+            <%= t("admin.common.dash") %>
+          <% end %>
+        </dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.platform") %></dt>
+        <dd><%= @session.platform %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.client_os") %></dt>
+        <dd><%= admin_session_client_os_label(@session) %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.app_version") %></dt>
+        <dd>
+          <% if @session.app_version.present? %>
+            <%= @session.app_version %>
+            <% if @session.app_build.present? %>
+              <span class="muted">(<%= @session.app_build %>)</span>
+            <% end %>
+          <% else %>
+            <%= t("admin.common.dash") %>
+          <% end %>
+        </dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.device") %></dt>
+        <dd>
+          <% device = [@session.device_manufacturer, @session.device_model].compact_blank.join(" ") %>
+          <%= device.presence || t("admin.common.dash") %>
+        </dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.os_version") %></dt>
+        <dd><%= @session.os_version.presence || t("admin.common.dash") %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.carrier") %></dt>
+        <dd><%= @session.carrier.presence || t("admin.common.dash") %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.privacy") %></dt>
+        <dd><%= @session.privacy_status %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.quality") %></dt>
+        <dd><%= @session.quality_preset %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.min_quality") %></dt>
+        <dd><%= @session.min_quality_preset %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.audio") %></dt>
+        <dd><%= @session.audio_muted? ? t("admin.sessions.show.audio_muted") : t("admin.sessions.show.audio_on") %></dd>
+      </div>
+    </dl>
+  </section>
+
+  <section class="panel">
+    <h3><%= t("admin.sessions.show.timing_title") %></h3>
+    <dl class="admin-kv">
+      <div>
+        <dt><%= t("admin.sessions.show.fields.created") %></dt>
+        <dd><%= admin_datetime(@session.created_at, with_seconds: true) %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.started") %></dt>
+        <dd><%= admin_datetime(@session.started_at, with_seconds: true) %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.ended") %></dt>
+        <dd><%= admin_datetime(@session.ended_at, with_seconds: true) %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.duration") %></dt>
+        <dd><%= admin_session_duration_label(@session) %></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.disconnects") %></dt>
+        <dd><%= @session.disconnection_count %></dd>
+      </div>
+      <% if @session.match.scheduled_at %>
+        <div>
+          <dt><%= t("admin.sessions.show.fields.scheduled") %></dt>
+          <dd><%= admin_datetime(@session.match.scheduled_at) %></dd>
+        </div>
+      <% end %>
+      <% if @session.match.location.present? %>
+        <div>
+          <dt><%= t("admin.sessions.show.fields.location") %></dt>
+          <dd><%= @session.match.location %></dd>
+        </div>
+      <% end %>
+    </dl>
+  </section>
+
+  <section class="panel">
+    <h3><%= t("admin.sessions.show.ingest_title") %></h3>
+    <dl class="admin-kv">
+      <div>
+        <dt><%= t("admin.sessions.show.fields.node") %></dt>
+        <dd>
+          <% slug = @session.ingest_slug_display %>
+          <% role = @session.ingest_role_display %>
+          <% if slug.present? %>
+            <code><%= slug %></code>
+            <% if role.present? %>
+              <span class="badge <%= admin_session_ingest_badge_class(role) %>">
+                <%= admin_session_ingest_role_label(role) %>
+              </span>
+            <% end %>
+            <% if @session.stream_node %>
+              <span class="muted">(<%= @session.stream_node.provider %>)</span>
+            <% else %>
+              <span class="muted"><%= t("admin.sessions.ingest.decommissioned") %></span>
+            <% end %>
+          <% else %>
+            <span class="muted"><%= t("admin.sessions.ingest.none") %></span>
+          <% end %>
+        </dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.rtmp") %></dt>
+        <dd><code class="admin-mono admin-mono--wrap"><%= @session.rtmp_ingest_url %></code></dd>
+      </div>
+      <div>
+        <dt><%= t("admin.sessions.show.fields.hls") %></dt>
+        <dd><code class="admin-mono admin-mono--wrap"><%= @session.hls_playback_url %></code></dd>
+      </div>
+      <% if @session.youtube_broadcast_id.present? %>
+        <div>
+          <dt><%= t("admin.sessions.show.youtube_studio") %></dt>
+          <dd>
+            <a href="https://studio.youtube.com/video/<%= @session.youtube_broadcast_id %>/livestreaming" target="_blank" rel="noopener">
+              <%= t("admin.sessions.show.broadcast") %>
+            </a>
+            <span class="muted">(<%= @session.youtube_broadcast_id %>)</span>
+          </dd>
+        </div>
+      <% end %>
+      <% if @session.recording %>
+        <div>
+          <dt><%= t("admin.sessions.show.fields.recording") %></dt>
+          <dd>
+            <span class="badge badge--<%= @session.recording.status == 'ready' ? 'ready' : 'paused' %>">
+              <%= @session.recording.status %>
+            </span>
+            <% if club %>
+              <%= link_to t("admin.sessions.show.open_replays"), admin_club_recordings_path(club) %>
+            <% end %>
+          </dd>
+        </div>
+      <% end %>
+    </dl>
+  </section>
+</div>
 
 <%= render "admin/sessions/links", session: @session %>
 
-<% if @session.youtube_broadcast_id %>
+<% if @session.device_states.any? %>
-  <p><%= t("admin.sessions.show.youtube_studio") %>: <a href="https://studio.youtube.com/video/<%= @session.youtube_broadcast_id %>/livestreaming" target="_blank" rel="noopener"><%= t("admin.sessions.show.broadcast") %></a></p>
+  <section class="panel">
+    <h3><%= t("admin.sessions.show.devices_title") %></h3>
+    <div class="admin-table-wrap">
+      <table class="admin-table">
+        <thead>
+          <tr>
+            <th><%= t("admin.sessions.show.devices.role") %></th>
+            <th><%= t("admin.sessions.show.devices.network") %></th>
+            <th><%= t("admin.sessions.show.devices.battery") %></th>
+            <th><%= t("admin.sessions.show.devices.bitrate") %></th>
+            <th><%= t("admin.sessions.show.devices.fps") %></th>
+            <th><%= t("admin.sessions.show.devices.last_seen") %></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @session.device_states.order(:device_role).each do |device| %>
+            <tr>
+              <td><%= device.device_role %></td>
+              <td class="muted"><%= device.network_type.presence || t("admin.common.dash") %></td>
+              <td class="muted"><%= device.battery_level.nil? ? t("admin.common.dash") : "#{device.battery_level}%" %></td>
+              <td class="muted">
+                <% if device.current_bitrate || device.target_bitrate %>
+                  <%= device.current_bitrate || t("admin.common.dash") %>
+                  <span class="muted">/ <%= device.target_bitrate || t("admin.common.dash") %></span>
+                <% else %>
+                  <%= t("admin.common.dash") %>
+                <% end %>
+              </td>
+              <td class="muted"><%= device.fps || t("admin.common.dash") %></td>
+              <td class="muted"><%= admin_datetime(device.last_seen_at, with_seconds: true) %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </section>
 <% end %>
-<p><%= t("admin.sessions.show.rtmp_ingest") %> <code><%= @session.rtmp_ingest_url %></code></p>
 
-<h3><%= t("admin.sessions.show.events_title") %></h3>
+<section class="panel">
-<table>
+  <h3><%= t("admin.sessions.show.events_title") %></h3>
-  <thead>
+  <% if @events.any? %>
-    <tr>
+    <div class="admin-table-wrap">
-      <th><%= t("admin.sessions.show.table.type") %></th>
+      <table class="admin-table admin-table--events">
-      <th><%= t("admin.sessions.show.table.when") %></th>
+        <thead>
-      <th><%= t("admin.sessions.show.table.meta") %></th>
+          <tr>
-    </tr>
+            <th><%= t("admin.sessions.show.table.type") %></th>
-  </thead>
+            <th><%= t("admin.sessions.show.table.when") %></th>
-  <tbody>
+            <th><%= t("admin.sessions.show.table.meta") %></th>
-    <% @events.each do |e| %>
+          </tr>
-      <tr>
+        </thead>
-        <td><%= e.event_type %></td>
+        <tbody>
-        <td><%= e.occurred_at %></td>
+          <% @events.each do |e| %>
-        <td><%= e.metadata.to_json %></td>
+            <tr>
-      </tr>
+              <td><span class="admin-event-type"><%= e.event_type %></span></td>
-    <% end %>
+              <td class="muted"><%= admin_datetime(e.occurred_at, with_seconds: true) %></td>
-  </tbody>
+              <td><%= admin_format_event_meta(e.metadata) %></td>
-</table>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  <% else %>
+    <p class="empty"><%= t("admin.sessions.show.events_none") %></p>
+  <% end %>
+</section>

backend/app/views/contact_mailer/inquiry.html.erb

@@ -0,0 +1,13 @@
+<p><strong><%= t("mailers.contact.heading") %></strong></p>
+
+<p>
+  <%= t("mailers.contact.name") %> <%= @name %><br>
+  <%= t("mailers.contact.email") %> <%= @email %><br>
+  <%= t("mailers.contact.club") %> <%= @club_name.presence || t("mailers.contact.club_none") %><br>
+  <%= t("mailers.contact.topic") %> <%= t("mailers.contact.topic_labels.#{@topic}") %>
+</p>
+
+<p><%= t("mailers.contact.message") %></p>
+<p style="white-space:pre-wrap"><%= @message %></p>
+
+<p style="color:#666;font-size:12px"><%= t("mailers.contact.footer") %></p>

backend/app/views/contact_mailer/inquiry.text.erb

@@ -0,0 +1,11 @@
+<%= t("mailers.contact.heading") %>
+
+<%= t("mailers.contact.name") %> <%= @name %>
+<%= t("mailers.contact.email") %> <%= @email %>
+<%= t("mailers.contact.club") %> <%= @club_name.presence || t("mailers.contact.club_none") %>
+<%= t("mailers.contact.topic") %> <%= t("mailers.contact.topic_labels.#{@topic}") %>
+
+<%= t("mailers.contact.message") %>
+<%= @message %>
+
+<%= t("mailers.contact.footer") %>

backend/app/views/layouts/admin.html.erb

@@ -4,7 +4,8 @@
   <title><%= t("admin.layout.title") %></title>
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="robots" content="noindex, nofollow">
-  <link rel="stylesheet" href="/admin.css?v=4">
+  <%= csrf_meta_tags %>
+  <link rel="stylesheet" href="/admin.css?v=15">
   <% if content_for?(:replay_archive_styles) %>
     <link rel="stylesheet" href="/marketing.css?v=42">
   <% end %>
@@ -25,10 +26,12 @@
         <%= link_to admin_ops_path, class: ("active" if controller_name == "ops") do %>
           <%= t("admin.layout.nav.ops") %><% if ops_critical.positive? %> <span class="admin-nav-badge"><%= ops_critical %></span><% end %>
         <% end %>
+        <%= link_to t("admin.layout.nav.announcements"), admin_announcements_path, class: ("active" if controller_name == "announcements") %>
         <%= link_to t("admin.layout.nav.clubs"), admin_clubs_path, class: ("active" if controller_name.in?(%w[clubs teams club_recordings])) %>
         <%= link_to t("admin.layout.nav.billing"), admin_billing_path, class: ("active" if controller_name.in?(%w[billing billing_invoices])) %>
         <%= link_to t("admin.layout.nav.youtube"), admin_youtube_platform_path, class: ("active" if controller_name == "youtube") %>
         <%= link_to t("admin.layout.nav.sessions"), admin_sessions_path, class: ("active" if controller_name == "sessions") %>
+        <%= link_to t("admin.layout.nav.analytics"), admin_analytics_path, class: ("active" if controller_name == "analytics") %>
         <%= link_to t("admin.layout.nav.stream_nodes"), admin_stream_nodes_path, class: ("active" if controller_name == "stream_nodes") %>
         <%= link_to t("admin.layout.nav.password"), edit_admin_password_path %>
         <%= button_to t("admin.layout.nav.logout"), admin_logout_path, method: :delete %>

backend/app/views/layouts/marketing.html.erb

@@ -5,14 +5,16 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title><%= content_for?(:title) ? yield(:title) : "Match Live TV" %></title>
     <meta name="application-name" content="Match Live TV">
+    <%= csrf_meta_tags %>
     <%= render "shared/meta_tags" %>
     <%= yield :head %>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css" integrity="sha512-SnH5WK+bZxgPHs44uWIX+LLJAJ9/2PkPKZ5QiAj6Ta86w+fsb2TkcmfRyVX3pBnMFcV7oQPJkl9QevSCWr3W6A==" crossorigin="anonymous" referrerpolicy="no-referrer">
-    <link rel="stylesheet" href="/marketing.css?v=64">
+    <link rel="stylesheet" href="/marketing.css?v=76">
   </head>
   <body data-confirm-i18n='<%= raw confirm_dialog_i18n_json %>'<% if MatchLiveTv.google_analytics_configured? %> data-ga-id="<%= MatchLiveTv.google_analytics_measurement_id %>"<% end %>>
     <%= render "shared/cookie_banner" %>
     <%= render(@app_store_review_chrome ? "shared/marketing_nav_app_store" : "shared/marketing_nav") %>
+    <%= render "shared/site_announcements" %>
     <main>
       <% if flash[:notice] %><div class="wrap"><div class="flash notice"><%= flash[:notice] %></div></div><% end %>
       <% if flash[:alert] %><div class="wrap"><div class="flash alert"><%= flash[:alert] %></div></div><% end %>
@@ -24,6 +26,7 @@
     <script src="/password-toggle.js?v=2" defer></script>
     <link rel="stylesheet" href="/confirm-forms.css?v=4">
     <script src="/confirm-forms.js?v=7" defer></script>
-    <script src="/cookie-consent.js?v=1" defer></script>
+    <script src="/site-analytics.js?v=4" defer></script>
+    <script src="/cookie-consent.js?v=2" defer></script>
   </body>
 </html>

backend/app/views/layouts/marketing_live.html.erb

@@ -4,21 +4,24 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title><%= content_for?(:title) ? yield(:title) : "Match Live TV" %></title>
+    <%= csrf_meta_tags %>
     <%= render "shared/meta_tags" %>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css" integrity="sha512-SnH5WK+bZxgPHs44uWIX+LLJAJ9/2PkPKZ5QiAj6Ta86w+fsb2TkcmfRyVX3pBnMFcV7oQPJkl9QevSCWr3W6A==" crossorigin="anonymous" referrerpolicy="no-referrer">
-    <link rel="stylesheet" href="/marketing.css?v=64">
+    <link rel="stylesheet" href="/marketing.css?v=76">
     <link rel="stylesheet" href="/live.css?v=26">
     <%= yield :head %>
   </head>
   <body data-confirm-i18n='<%= raw confirm_dialog_i18n_json %>'<% if MatchLiveTv.google_analytics_configured? %> data-ga-id="<%= MatchLiveTv.google_analytics_measurement_id %>"<% end %>>
     <%= render "shared/cookie_banner" %>
     <%= render "shared/marketing_nav" %>
+    <%= render "shared/site_announcements" %>
     <main class="live-main">
       <%= yield %>
     </main>
     <%= render "shared/marketing_footer" %>
     <link rel="stylesheet" href="/confirm-forms.css?v=4">
     <script src="/confirm-forms.js?v=7" defer></script>
-    <script src="/cookie-consent.js?v=1" defer></script>
+    <script src="/site-analytics.js?v=4" defer></script>
+    <script src="/cookie-consent.js?v=2" defer></script>
   </body>
 </html>

backend/app/views/public/clubs/edit.html.erb

@@ -1,7 +1,7 @@
 <% content_for :title, t("club.edit.title", name: @club.name) %>
 <% content_for :robots, "noindex, nofollow" %>
 
-<div class="wrap" style="padding-top:20px;max-width:560px">
+<div class="wrap wrap--portal" style="padding-top:20px">
   <h1><%= t("club.edit.heading") %></h1>
   <div class="card">
     <%= form_with url: public_club_path(@club), method: :patch, multipart: true do %>
@@ -10,6 +10,9 @@
       <%= label_tag "club[sport]", t("club.sport_label") %>
       <%= select_tag "club[sport]", sport_catalog_options(@club.sport) %>
       <%= render "shared/branding_fields", record: @club, legend: t("club.branding_legend") %>
+      <%= render "shared/cover_fields",
+            record: @club,
+            can_upload: @entitlements&.can_use_custom_cover? %>
       <%= render "shared/billing_profile_fields", record: @club %>
       <%= submit_tag t("club.edit.save"), class: "btn btn-primary" %>
     <% end %>

backend/app/views/public/contacts/show.html.erb

@@ -0,0 +1,131 @@
+<% content_for :title, t("pages.contacts.meta_title") %>
+<% content_for :meta_description, t("pages.contacts.meta_description") %>
+<% content_for :canonical_url, seo_absolute_url(public_contatti_path) %>
+
+<article class="contacts-page">
+  <header class="features-hero contacts-hero">
+    <div class="wrap">
+      <p class="features-hero__eyebrow"><%= t("pages.contacts.eyebrow") %></p>
+      <h1><%= t("pages.contacts.title") %></h1>
+      <p class="features-hero__lead"><%= t("pages.contacts.lead") %></p>
+      <p class="contacts-hero__meta"><%= t("pages.contacts.response_time") %></p>
+    </div>
+  </header>
+
+  <section class="section wrap" aria-label="<%= t("pages.contacts.title") %>">
+    <div class="contacts-channels">
+      <article class="feature-card">
+        <span class="feature-card__icon" aria-hidden="true"><i class="fa-solid fa-briefcase"></i></span>
+        <h2><%= t("pages.contacts.commercial_title") %></h2>
+        <p><%= t("pages.contacts.commercial_body") %></p>
+        <p class="contacts-channels__email">
+          <%= mail_to MatchLiveTv.support_email, MatchLiveTv.support_email %>
+        </p>
+      </article>
+
+      <article class="feature-card">
+        <span class="feature-card__icon feature-card__icon--blue" aria-hidden="true"><i class="fa-solid fa-life-ring"></i></span>
+        <h2><%= t("pages.contacts.support_title") %></h2>
+        <p>
+          <%= raw t(
+            "pages.contacts.support_body_html",
+            faq_link: link_to(t("pages.contacts.faq_link"), public_faq_path),
+            support_link: link_to(t("pages.contacts.support_link"), public_support_path)
+          ) %>
+        </p>
+        <p class="contacts-channels__email">
+          <%= mail_to MatchLiveTv.support_email, MatchLiveTv.support_email %>
+        </p>
+      </article>
+
+      <article class="feature-card">
+        <span class="feature-card__icon feature-card__icon--gold" aria-hidden="true"><i class="fa-solid fa-shield-halved"></i></span>
+        <h2><%= t("pages.contacts.privacy_title") %></h2>
+        <p><%= t("pages.contacts.privacy_body") %></p>
+        <p class="contacts-channels__email">
+          <%= mail_to MatchLiveTv.privacy_controller_email, MatchLiveTv.privacy_controller_email %>
+        </p>
+      </article>
+    </div>
+  </section>
+
+  <section class="section wrap" aria-labelledby="contacts-company-title">
+    <div class="features-panel contacts-company">
+      <h2 id="contacts-company-title"><%= t("pages.contacts.company_title") %></h2>
+      <p class="features-panel__lead"><%= t("pages.contacts.company_lead") %></p>
+      <ul class="contacts-company__details">
+        <li><strong><%= MatchLiveTv.privacy_controller_name %></strong></li>
+        <li><%= t("pages.contacts.label_address") %>: <%= MatchLiveTv.privacy_controller_address %></li>
+        <% if MatchLiveTv.privacy_controller_vat.present? %>
+          <li><%= t("pages.contacts.label_vat") %>: <%= MatchLiveTv.privacy_controller_vat %></li>
+        <% end %>
+      </ul>
+    </div>
+  </section>
+
+  <section class="section wrap" aria-labelledby="contacts-social-title">
+    <div class="features-panel contacts-social">
+      <h2 id="contacts-social-title"><%= t("pages.contacts.social_title") %></h2>
+      <%= render "shared/social_links", modifier: "panel" %>
+    </div>
+  </section>
+
+  <section class="section wrap" aria-labelledby="contacts-form-title">
+    <div class="contacts-form-panel">
+      <h2 id="contacts-form-title"><%= t("pages.contacts.form_title") %></h2>
+      <p class="contacts-form-panel__lead"><%= t("pages.contacts.form_lead") %></p>
+
+      <%= form_with url: public_contatti_path, method: :post, local: true, class: "contacts-form" do %>
+        <div class="contacts-hp" aria-hidden="true">
+          <label for="website"><%= t("pages.contacts.honeypot_label") %></label>
+          <%= text_field_tag :website, @inquiry[:website], tabindex: -1, autocomplete: "off" %>
+        </div>
+
+        <%= label_tag :name, t("pages.contacts.name_label") %>
+        <%= text_field_tag :name, @inquiry[:name], required: true, maxlength: 120, autocomplete: "name" %>
+
+        <%= label_tag :email, t("pages.contacts.email_label") %>
+        <%= email_field_tag :email, @inquiry[:email], required: true, autocomplete: "email" %>
+
+        <%= label_tag :club_name, t("pages.contacts.club_label") %>
+        <%= text_field_tag :club_name, @inquiry[:club_name], maxlength: 160, autocomplete: "organization" %>
+
+        <%= label_tag :topic, t("pages.contacts.topic_label") %>
+        <%= select_tag :topic, options_for_select(
+              [
+                [t("pages.contacts.topic_commercial"), "commercial"],
+                [t("pages.contacts.topic_support"), "support"],
+                [t("pages.contacts.topic_privacy"), "privacy"]
+              ],
+              @inquiry[:topic]
+            ), required: true %>
+
+        <%= label_tag :message, t("pages.contacts.message_label") %>
+        <%= text_area_tag :message, @inquiry[:message], required: true, rows: 6, maxlength: 4000 %>
+
+        <label class="legal-accept">
+          <%= check_box_tag :accept_privacy, "1", @inquiry[:accept_privacy] == "1", required: true %>
+          <span class="legal-accept-text">
+            <%= raw t(
+              "pages.contacts.privacy_accept_html",
+              privacy_link: link_to(t("pages.contacts.privacy_link"), public_privacy_path, target: "_blank", rel: "noopener")
+            ) %>
+          </span>
+        </label>
+
+        <%= submit_tag t("pages.contacts.submit"), class: "btn btn-primary" %>
+      <% end %>
+    </div>
+  </section>
+
+  <section class="section wrap features-cta" aria-labelledby="contacts-cta-title">
+    <div class="features-cta__box">
+      <h2 id="contacts-cta-title"><%= t("pages.contacts.cta_title") %></h2>
+      <p><%= t("pages.contacts.cta_body") %></p>
+      <div class="features-cta__actions">
+        <%= link_to t("pages.contacts.cta_faq"), public_faq_path, class: "btn btn-outline" %>
+        <%= link_to t("pages.contacts.cta_signup"), public_signup_path, class: "btn btn-primary" %>
+      </div>
+    </div>
+  </section>
+</article>

backend/app/views/public/live/show.html.erb

@@ -46,7 +46,7 @@
   </div>
 <% else %>
   <div class="live-player-wrap">
-    <video id="player" controls playsinline muted autoplay poster="/images/copertina-canale.png"></video>
+    <video id="player" controls playsinline muted autoplay poster="<%= @cover_poster_url %>"></video>
     <%= render "public/live/player_overlays", match: @match, session: @session %>
     <button type="button" id="play-hint" class="live-play-hint" hidden>
       <%= t("live.show.play_hint") %>
@@ -219,7 +219,8 @@
     }
 
     function onEnterPause() {
-      nudgePlayback();
+      // Camera → slate cambia risoluzione/codec: senza reload HLS.js resta spesso bloccato.
+      hardReloadPlayer();
     }
 
     function hardReloadPlayer() {

backend/app/views/public/pages/cookies.html.erb

@@ -101,6 +101,12 @@
           <td><%= t("legal.cookies.s4_2_row3_duration") %></td>
           <td><%= t("legal.cookies.s4_2_row3_provider") %></td>
         </tr>
+        <tr>
+          <td><%= raw t("legal.cookies.s4_2_row4_name_html") %></td>
+          <td><%= t("legal.cookies.s4_2_row4_purpose") %></td>
+          <td><%= t("legal.cookies.s4_2_row4_duration") %></td>
+          <td><%= t("legal.cookies.s4_2_row4_provider") %></td>
+        </tr>
       </tbody>
       </table>
     </div>

backend/app/views/public/pages/pricing.html.erb

@@ -83,6 +83,6 @@
   <div class="card" style="margin-top:32px;text-align:center">
     <h3 style="margin-top:0"><%= t("pages.pricing.different_title") %></h3>
     <p style="color:#aaa;margin-bottom:16px"><%= t("pages.pricing.different_body") %></p>
-    <%= mail_to "info@matchlivetv.it", t("pages.pricing.contact_button"), class: "btn btn-primary" %>
+    <%= link_to t("pages.pricing.contact_button"), public_contatti_path, class: "btn btn-primary" %>
   </div>
 </div>

backend/app/views/public/pages/privacy.html.erb

@@ -43,6 +43,7 @@
       <li><%= raw t("legal.privacy.s3_item4_html") %></li>
       <li><%= raw t("legal.privacy.s3_item5_html") %></li>
       <li><%= raw t("legal.privacy.s3_item6_html") %></li>
+      <li><%= raw t("legal.privacy.s3_item7_html") %></li>
     </ul>
   </section>
 
@@ -107,6 +108,10 @@
           <td><%= t("legal.privacy.s5_row6_purpose") %></td>
           <td><%= t("legal.privacy.s5_row6_basis") %></td>
         </tr>
+        <tr>
+          <td><%= t("legal.privacy.s5_row7_purpose") %></td>
+          <td><%= t("legal.privacy.s5_row7_basis") %></td>
+        </tr>
       </tbody>
       </table>
     </div>
@@ -144,6 +149,7 @@
       <li><%= raw t("legal.privacy.s8_item2_html") %></li>
       <li><%= raw t("legal.privacy.s8_item3_html") %></li>
       <li><%= raw t("legal.privacy.s8_item4_html", hours: MatchLiveTv.password_reset_expiry_hours) %></li>
+      <li><%= raw t("legal.privacy.s8_item5_html") %></li>
     </ul>
   </section>
 

backend/app/views/public/regia/show.html.erb

@@ -165,4 +165,4 @@
   </div>
 </div>
 
-<script src="/regia.js?v=19"></script>
+<script src="/regia.js?v=20"></script>

backend/app/views/public/replay/show.html.erb

@@ -43,9 +43,9 @@
     </p>
 
     <% ent = @recording.team.entitlements %>
-    <% if (ent.phone_download_enabled? && (logged_in? || @recording.unlisted?)) || @recording.youtube_watch_url %>
+    <% if (ent.phone_download_enabled? && @recording.storage_key.present? && (logged_in? || @recording.unlisted?)) || @recording.youtube_watch_url %>
       <div class="replay-show__actions">
-        <% if ent.phone_download_enabled? && (logged_in? || @recording.unlisted?) %>
+        <% if ent.phone_download_enabled? && @recording.storage_key.present? && (logged_in? || @recording.unlisted?) %>
           <%= link_to t("replay.show.download_link"), public_replay_download_path(@session), class: "btn btn-primary" %>
         <% end %>
         <% if @recording.youtube_watch_url %>
@@ -53,7 +53,7 @@
         <% end %>
       </div>
     <% end %>
-  <% elsif @recording.ready? && @recording.youtube_watch_url.present? %>
+  <% elsif @recording.ready? && @recording.replay_source == "youtube" && @recording.youtube_video_id.present? && !@recording.youtube_video_id.to_s.start_with?("mock_") %>
     <div class="live-player-wrap live-player-wrap--embed">
       <iframe src="https://www.youtube.com/embed/<%= @recording.youtube_video_id %>"
               title="<%= @recording.title_or_default %>"
@@ -68,6 +68,14 @@
           badge_label: t("replay.show.badge_label"),
           badge_class: "badge-ended" %>
     </div>
+    <p class="replay-show__meta-line">
+      <%= l_local(@recording.recorded_at_or_fallback) %>
+      · <%= t("replay.show.meta_line_duration", value: @recording.duration_label) %>
+      · <%= @recording.views_label %>
+      <% if @recording.source_platform_label != "—" %>
+        · <%= @recording.source_platform_label %>
+      <% end %>
+    </p>
     <p class="replay-show__meta-line">
       <%= t("replay.show.youtube_only_body") %>
       <%= link_to t("replay.show.youtube_link"), @recording.youtube_watch_url, target: "_blank", rel: "noopener" %>