Non far crashare il reset password se SMTP rifiuta il destinatario.

Un account di test su dominio .test faceva 500; ora l'invio fallito viene loggato e l'API resta ok.

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,164 @@
+# 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
+      }
+      @analytics_preview_active = analytics_preview_active?
+
+      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?
+
+      from = parse_date(params[:from]) || 7.days.ago.to_date
+      to = parse_date(params[:to]) || Time.zone.today
+      @device_tab_stats = device_tab_stats(@page_path, from, to)
+      device = resolve_heatmap_device(@device_tab_stats, params[:device].presence)
+
+      @filters = {
+        from: from,
+        to: to,
+        device: device,
+        layer: params[:layer].to_s
+      }
+
+      cells = AnalyticsPageCell.where(
+        page_path: @page_path,
+        day: @filters[:from]..@filters[:to],
+        device: @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],
+        device: @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
+
+    def preview_enable
+      Analytics::Suppress.enable!(cookies)
+      redirect_to preview_return_to(params[:return_to]), notice: t("admin.analytics.preview.enabled")
+    end
+
+    def preview_disable
+      Analytics::Suppress.disable!(cookies)
+      redirect_to admin_analytics_path, notice: t("admin.analytics.preview.disabled")
+    end
+
+    private
+
+    def analytics_preview_active?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    end
+
+    def preview_return_to(value)
+      path = value.to_s.strip
+      return root_path if path.blank?
+      return path if path.start_with?("/") && !path.start_with?("//")
+
+      admin_analytics_path
+    end
+
+    def parse_date(value)
+      return nil if value.blank?
+
+      Date.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def device_tab_stats(page_path, from, to)
+      cell_totals = AnalyticsPageCell.where(page_path: page_path, day: from..to)
+        .group(:device)
+        .pluck(
+          :device,
+          Arel.sql("SUM(click_count)"),
+          Arel.sql("SUM(move_count)")
+        )
+      cell_by_device = cell_totals.to_h { |device, clicks, moves| [device, { clicks: clicks.to_i, moves: moves.to_i }] }
+
+      pageview_totals = AnalyticsPageStat.where(page_path: page_path, day: from..to)
+        .group(:device)
+        .sum(:pageview_count)
+
+      AnalyticsEvent::DEVICES.index_with do |device|
+        cells = cell_by_device[device] || { clicks: 0, moves: 0 }
+        cells.merge(pageviews: pageview_totals[device].to_i)
+      end
+    end
+
+    def resolve_heatmap_device(tab_stats, requested)
+      if requested.present? && AnalyticsEvent::DEVICES.include?(requested)
+        return requested
+      end
+
+      AnalyticsEvent::DEVICES.max_by do |device|
+        stats = tab_stats[device]
+        stats[:clicks] + stats[:moves] + stats[:pageviews]
+      end
+    end
+
+    def find_snapshot(page_path, device)
+      return nil unless AnalyticsEvent::DEVICES.include?(device)
+
+      AnalyticsPageSnapshot.where(page_path: page_path, device: device)
+        .order(captured_at: :desc)
+        .detect { |snapshot| snapshot.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/cost_entries_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Admin
+  class CostEntriesController < Admin::BaseController
+    before_action :set_entry, only: %i[edit update destroy]
+
+    def new
+      @entry = PlatformCostEntry.new(
+        month: parse_month(params[:month]) || Time.zone.today.beginning_of_month,
+        label: PlatformCostEntry::DEFAULT_LABEL
+      )
+    end
+
+    def create
+      @entry = PlatformCostEntry.new(entry_attributes)
+      if @entry.save
+        redirect_to admin_costs_path(month: month_param(@entry.month)), notice: t("admin.flash.cost_entry_created")
+      else
+        flash.now[:alert] = @entry.errors.full_messages.join(", ")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @entry.update(entry_attributes)
+        redirect_to admin_costs_path(month: month_param(@entry.month)), notice: t("admin.flash.cost_entry_updated")
+      else
+        flash.now[:alert] = @entry.errors.full_messages.join(", ")
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      month = @entry.month
+      @entry.destroy!
+      redirect_to admin_costs_path(month: month_param(month)), notice: t("admin.flash.cost_entry_destroyed")
+    end
+
+    private
+
+    def set_entry
+      @entry = PlatformCostEntry.find(params[:id])
+    end
+
+    def entry_attributes
+      attrs = params.require(:platform_cost_entry).permit(:month, :label, :amount_euros, :notes)
+      if attrs[:amount_euros].present?
+        attrs[:amount_cents] = Billing::EuroAmount.to_cents(attrs.delete(:amount_euros))
+      end
+      attrs[:notes] = nil if attrs[:notes].blank?
+      attrs
+    end
+
+    def parse_month(value)
+      return nil if value.blank?
+
+      Date.strptime(value.to_s, "%Y-%m").beginning_of_month
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def month_param(date)
+      date.strftime("%Y-%m")
+    end
+  end
+end

backend/app/controllers/admin/costs_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Admin
+  class CostsController < Admin::BaseController
+    def index
+      @month = parse_month(params[:month]) || Time.zone.today.beginning_of_month
+      analytics = Admin::CostAnalytics.new(month: @month)
+      @summary = analytics.summary
+      @trend = analytics.trend
+      @clubs = analytics.club_breakdown
+      @entries = PlatformCostEntry.for_month(@month).ordered
+      @month_options = month_options(@month)
+    end
+
+    private
+
+    def parse_month(value)
+      return nil if value.blank?
+
+      Date.strptime(value.to_s, "%Y-%m").beginning_of_month
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def month_options(selected)
+      start = selected - 23.months
+      (0..23).map { |i| start + i.months }.reverse
+    end
+  end
+end

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,45 @@
+# frozen_string_literal: true
+
+module Analytics
+  class EventsController < ActionController::API
+    include ActionController::Cookies
+
+    def create
+      if analytics_suppressed?
+        return render json: { accepted: 0, rejected: 0, suppressed: true }, status: :accepted
+      end
+
+      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 analytics_suppressed?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    end
+
+    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,33 @@
+# frozen_string_literal: true
+
+module Analytics
+  class SnapshotsController < ActionController::API
+    include ActionController::Cookies
+
+    def create
+      if analytics_suppressed?
+        return render json: { ok: true, skipped: true, suppressed: true }, status: :accepted
+      end
+
+      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
+
+    private
+
+    def analytics_suppressed?
+      Analytics::Suppress.active?(cookies[Analytics::Suppress::COOKIE_NAME])
+    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,7 @@ 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
 
@@ -22,6 +23,13 @@ module Api
         }, 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

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

@@ -171,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/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/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/helpers/admin_helper.rb

@@ -1,4 +1,21 @@
 module AdminHelper
+  def format_euros(cents, precision: 2)
+    return I18n.t("admin.common.dash") if cents.nil?
+
+    format("%.*f €", precision, cents.to_f / 100.0)
+  end
+
+  def format_hours(hours)
+    return I18n.t("admin.common.dash") if hours.nil? || hours.to_f <= 0
+
+    total_minutes = (hours.to_f * 60).round
+    format_duration_minutes(total_minutes)
+  end
+
+  def admin_month_label(month)
+    I18n.l(month, format: "%B %Y")
+  end
+
   def format_bytes(bytes)
     return "—" if bytes.nil?
 
@@ -30,6 +47,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 +161,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/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/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/platform_cost_entry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class PlatformCostEntry < ApplicationRecord
+  DEFAULT_LABEL = "Piattaforma produzione"
+
+  validates :month, presence: true
+  validates :label, presence: true, length: { maximum: 120 }
+  validates :amount_cents, numericality: { only_integer: true, greater_than: 0 }
+
+  before_validation :normalize_month
+
+  scope :for_month, ->(date) { where(month: date.to_date.beginning_of_month) }
+  scope :ordered, -> { order(month: :desc, created_at: :desc) }
+
+  def month=(value)
+    if value.is_a?(String) && value.match?(/\A\d{4}-\d{2}\z/)
+      super(Date.strptime(value, "%Y-%m"))
+    else
+      super(value)
+    end
+  end
+
+  def amount_euros
+    amount_cents.to_f / 100.0
+  end
+
+  private
+
+  def normalize_month
+    return if month.blank?
+
+    parsed =
+      case month
+      when Date
+        month
+      when Time, ActiveSupport::TimeWithZone
+        month.to_date
+      when String
+        if month.match?(/\A\d{4}-\d{2}\z/)
+          Date.strptime(month, "%Y-%m")
+        else
+          Date.parse(month)
+        end
+      else
+        Date.parse(month.to_s)
+      end
+    self.month = parsed.beginning_of_month
+  rescue ArgumentError, TypeError
+    errors.add(:month, :invalid)
+  end
+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/services/admin/cost_analytics.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Admin
+  class CostAnalytics
+    TREND_MONTHS = 12
+
+    def initialize(month:)
+      @month = month.to_date.beginning_of_month
+    end
+
+    def summary
+      build_period(@month)
+    end
+
+    def trend(months: TREND_MONTHS)
+      start_month = @month - (months - 1).months
+      months_list = (0...months).map { |i| start_month + i.months }
+      months_list.map { |m| build_period(m) }
+    end
+
+    def club_breakdown
+      range = month_range(@month)
+      rows = session_rows(range)
+      total_secs = rows.sum { |row| row.total_secs.to_i }
+      total_cost_cents = PlatformCostEntry.for_month(@month).sum(:amount_cents)
+      revenue_by_club = revenue_by_club(range)
+      storage_by_club = storage_by_club_index
+      club_ids = rows.map(&:club_id)
+      clubs = Club.where(id: club_ids).includes(subscription: :plan).index_by(&:id)
+
+      rows.map do |row|
+        club = clubs[row.club_id]
+        secs = row.total_secs.to_i
+        hours = secs / 3600.0
+        sessions_count = row.sessions_count.to_i
+        share = total_secs.positive? ? secs.to_f / total_secs : 0.0
+        allocated_cents = (total_cost_cents * share).round
+        revenue_cents = revenue_by_club[row.club_id].to_i
+        storage_bytes = storage_by_club[row.club_id].to_i
+
+        {
+          club_id: row.club_id,
+          club_name: row.club_name,
+          plan_slug: club&.subscription&.plan&.slug,
+          sessions: sessions_count,
+          hours: hours.round(2),
+          hours_share_pct: (share * 100).round(1),
+          allocated_cost_cents: allocated_cents,
+          revenue_cents: revenue_cents,
+          margin_cents: revenue_cents - allocated_cents,
+          cost_per_hour_cents: hours.positive? ? (allocated_cents / hours).round : nil,
+          cost_per_session_cents: sessions_count.positive? ? (allocated_cents / sessions_count) : nil,
+          storage_bytes: storage_bytes
+        }
+      end.sort_by { |row| [-row[:hours], row[:club_name]] }
+    end
+
+    private
+
+    def build_period(month)
+      range = month_range(month)
+      cost_cents = PlatformCostEntry.for_month(month).sum(:amount_cents)
+      sessions_scope = ended_sessions.where(ended_at: range)
+      total_secs = sessions_scope.sum(:total_duration_secs).to_i
+      hours = total_secs / 3600.0
+      sessions = sessions_scope.count
+      clubs_active = distinct_active_clubs(range)
+      revenue_cents = Billing::Payment.where(status: "paid", paid_at: range).sum(:amount_cents)
+      storage_bytes = Recording.ready.sum(:byte_size).to_i
+      storage_gb = storage_bytes.positive? ? storage_bytes / (1024.0**3) : 0.0
+
+      kpis = compute_kpis(
+        cost_cents: cost_cents,
+        hours: hours,
+        sessions: sessions,
+        clubs_active: clubs_active,
+        revenue_cents: revenue_cents,
+        storage_gb: storage_gb
+      )
+
+      {
+        month: month,
+        cost_cents: cost_cents,
+        sessions: sessions,
+        hours: hours.round(2),
+        clubs_active: clubs_active,
+        revenue_cents: revenue_cents,
+        storage_bytes: storage_bytes,
+        **kpis
+      }
+    end
+
+    def compute_kpis(cost_cents:, hours:, sessions:, clubs_active:, revenue_cents:, storage_gb:)
+      margin_cents = revenue_cents.to_i - cost_cents.to_i
+      margin_pct = revenue_cents.to_i.positive? ? ((margin_cents.to_f / revenue_cents.to_i) * 100).round(1) : nil
+      hours_f = hours.to_f
+      sessions_i = sessions.to_i
+      clubs_i = clubs_active.to_i
+      storage_f = storage_gb.to_f
+      cost_i = cost_cents.to_i
+
+      {
+        cost_per_hour_cents: hours_f.positive? ? (cost_i / hours_f).round : nil,
+        cost_per_session_cents: sessions_i.positive? ? (cost_i / sessions_i) : nil,
+        cost_per_club_cents: clubs_i.positive? ? (cost_i / clubs_i) : nil,
+        revenue_per_hour_cents: hours_f.positive? ? (revenue_cents.to_i / hours_f).round : nil,
+        cost_per_gb_cents: storage_f.positive? ? (cost_i / storage_f).round : nil,
+        margin_cents: margin_cents,
+        margin_pct: margin_pct
+      }
+    end
+
+    def month_range(month)
+      month.beginning_of_month.beginning_of_day..month.end_of_month.end_of_day
+    end
+
+    def ended_sessions
+      StreamSession.where(status: "ended")
+    end
+
+    def distinct_active_clubs(range)
+      ended_sessions
+        .where(ended_at: range)
+        .joins(match: { team: :club })
+        .distinct
+        .count("clubs.id")
+    end
+
+    def session_rows(range)
+      ended_sessions
+        .where(ended_at: range)
+        .joins(match: { team: :club })
+        .group("clubs.id", "clubs.name")
+        .select(
+          "clubs.id AS club_id",
+          "clubs.name AS club_name",
+          "COUNT(stream_sessions.id) AS sessions_count",
+          "SUM(stream_sessions.total_duration_secs) AS total_secs"
+        )
+    end
+
+    def revenue_by_club(range)
+      Billing::Payment.where(status: "paid", paid_at: range).group(:club_id).sum(:amount_cents)
+    end
+
+    def storage_by_club_index
+      Recording.ready.joins(:team).group("teams.club_id").sum(:byte_size)
+    end
+  end
+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/analytics/suppress.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Analytics
+  module Suppress
+    COOKIE_NAME = "mltv_analytics_suppress"
+    COOKIE_MAX_AGE = 7 * 24 * 60 * 60
+
+    module_function
+
+    def active?(cookie_value)
+      cookie_value.to_s == "1"
+    end
+
+    def enable!(cookie_jar)
+      cookie_jar[COOKIE_NAME] = cookie_options(value: "1", expires: COOKIE_MAX_AGE.seconds.from_now)
+    end
+
+    def disable!(cookie_jar)
+      cookie_jar.delete(
+        COOKIE_NAME,
+        path: "/",
+        same_site: :lax,
+        secure: cookie_secure?
+      )
+    end
+
+    def cookie_options(value:, expires:)
+      {
+        value: value,
+        expires: expires,
+        path: "/",
+        httponly: true,
+        same_site: :lax,
+        secure: cookie_secure?
+      }
+    end
+
+    def cookie_secure?
+      Rails.application.config.force_ssl || Rails.env.production?
+    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
@@ -30,7 +46,9 @@ module Mediamtx
       body[:alwaysAvailable] = true
       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}"
@@ -161,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?

backend/app/services/ops/health_checks.rb

@@ -54,6 +54,8 @@ module Ops
     def process_finding(finding)
       if finding.healthy
         Ops::IncidentRecorder.resolve(fingerprint: finding.fingerprint)
+        # overflow usa fingerprint diverse (at_max / orphan_idle / budget) rispetto al check sano
+        Ops::IncidentRecorder.resolve_kind(finding.kind) if finding.kind == "stream_overflow"
       else
         Ops::IncidentRecorder.record(
           kind: finding.kind,

backend/app/services/ops/incident_recorder.rb

@@ -10,6 +10,10 @@ module Ops
       def resolve(fingerprint:)
         new.resolve(fingerprint: fingerprint)
       end
+
+      def resolve_kind(kind)
+        new.resolve_kind(kind)
+      end
     end
 
     def record(finding)
@@ -49,6 +53,10 @@ module Ops
       Ops::Incident.open.where(fingerprint: fingerprint).find_each(&:resolve!)
     end
 
+    def resolve_kind(kind)
+      Ops::Incident.open.where(kind: kind).find_each(&:resolve!)
+    end
+
     private
 
     def fingerprint_for(finding)

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/notify_expiring.rb

@@ -23,7 +23,7 @@ module Recordings
     private
 
     def deliver_expiring_soon(user)
-      Recordings::ReplayMailer.replay_expiring_soon(recording: @recording, recipient: user).deliver_now
+      MatchLiveTv.deliver_mail(Recordings::ReplayMailer.replay_expiring_soon(recording: @recording, recipient: user))
     rescue EOFError => e
       Rails.logger.warn("[Recordings::NotifyExpiring] SMTP EOF on close for #{user.email}: #{e.message}")
     end

backend/app/services/recordings/notify_ready.rb

@@ -19,7 +19,7 @@ module Recordings
     private
 
     def deliver_replay_ready(user)
-      Recordings::ReplayMailer.replay_ready(recording: @recording, recipient: user).deliver_now
+      MatchLiveTv.deliver_mail(Recordings::ReplayMailer.replay_ready(recording: @recording, recipient: user))
     rescue EOFError => e
       # Aruba SMTP (465/SSL) chiude la socket prima del QUIT: la mail è già partita.
       Rails.logger.warn("[Recordings::NotifyReady] SMTP EOF on close for #{user.email}: #{e.message}")

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"
@@ -46,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/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/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/users/request_password_reset.rb

@@ -13,7 +13,7 @@ module Users
       return if user.nil?
 
       token = user.generate_password_reset!
-      UserMailer.password_reset(user, token).deliver_now
+      MatchLiveTv.deliver_mail(UserMailer.password_reset(user, token))
     end
   end
 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,99 @@
+<% 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>
+
+<section class="panel admin-analytics-preview">
+  <h3><%= t("admin.analytics.preview.title") %></h3>
+  <p class="muted admin-table-sub"><%= t("admin.analytics.preview.lead") %></p>
+  <% if @analytics_preview_active %>
+    <p class="admin-analytics-preview__status"><%= t("admin.analytics.preview.active") %></p>
+    <div class="admin-filter-actions">
+      <%= button_to t("admin.analytics.preview.disable"),
+            admin_analytics_preview_path,
+            method: :delete,
+            class: "admin-btn admin-btn--outline admin-btn--sm" %>
+      <%= link_to t("admin.analytics.preview.open_site"),
+            root_path,
+            class: "admin-btn admin-btn--primary admin-btn--sm",
+            target: "_blank",
+            rel: "noopener" %>
+    </div>
+  <% else %>
+    <div class="admin-filter-actions">
+      <%= button_to t("admin.analytics.preview.enable"),
+            admin_analytics_preview_path(return_to: root_path),
+            method: :post,
+            class: "admin-btn admin-btn--primary admin-btn--sm" %>
+    </div>
+  <% end %>
+</section>
+
+<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>
+                <% heatmap_params = { page_path: row[:page_path], from: @filters[:from], to: @filters[:to] } %>
+                <% heatmap_params[:device] = @filters[:device] if @filters[:device].present? %>
+                <%= link_to t("admin.analytics.index.heatmap"), admin_analytics_page_path(heatmap_params) %>
+              </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,166 @@
+<% 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]) %>
+    </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">
+  <p class="admin-filter-field" style="margin-bottom: 0.75rem;">
+    <span><%= t("admin.analytics.show.device_tabs_label") %></span>
+  </p>
+  <div class="admin-locale-tabs" role="tablist">
+    <% AnalyticsEvent::DEVICES.each do |device| %>
+      <% stats = @device_tab_stats[device] %>
+      <% active = @filters[:device] == device %>
+      <%= link_to admin_analytics_page_path(
+            page_path: @page_path,
+            from: @filters[:from],
+            to: @filters[:to],
+            device: device,
+            layer: @filters[:layer]
+          ),
+          class: "admin-locale-tab #{'is-active' if active}",
+          role: "tab",
+          "aria-selected": active do %>
+        <%= t("admin.analytics.devices.#{device}") %>
+        <span class="admin-device-tab-count"><%= stats[:pageviews] %></span>
+      <% end %>
+    <% end %>
+  </div>
+
+  <%= form_with url: admin_analytics_page_path, method: :get, local: true, class: "admin-filter-form" do %>
+    <%= hidden_field_tag :page_path, @page_path %>
+    <%= hidden_field_tag :device, @filters[:device] %>
+    <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.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",
+          device: t("admin.analytics.devices.#{@filters[:device]}")
+        ) %>
+  </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: t("admin.analytics.devices.#{@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",
+                device: t("admin.analytics.devices.#{@filters[:device]}")
+              ) %>
+        </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/cost_entries/_form.html.erb

@@ -0,0 +1,34 @@
+<%= form_with model: @entry, url: url, method: method, local: true, class: "admin-filter-form" do |f| %>
+  <div class="admin-filter-grid">
+    <label class="admin-filter-field">
+      <span><%= t("admin.costs.entries.month") %></span>
+      <%= text_field_tag "platform_cost_entry[month]",
+            @entry.month&.strftime("%Y-%m"),
+            type: "month",
+            required: true %>
+    </label>
+    <label class="admin-filter-field">
+      <span><%= t("admin.costs.entries.label") %></span>
+      <%= f.text_field :label, required: true, maxlength: 120 %>
+      <span class="muted admin-table-sub"><%= t("admin.costs.entries.label_hint") %></span>
+    </label>
+    <label class="admin-filter-field">
+      <span><%= t("admin.costs.entries.amount") %></span>
+      <%= number_field_tag "platform_cost_entry[amount_euros]",
+            (@entry.amount_cents.to_f / 100.0 if @entry.amount_cents.present?),
+            step: 0.01,
+            min: 0.01,
+            required: true %>
+    </label>
+    <label class="admin-filter-field" style="grid-column: span 2;">
+      <span><%= t("admin.costs.entries.notes") %></span>
+      <%= f.text_area :notes, rows: 3 %>
+    </label>
+  </div>
+  <div class="admin-filter-actions">
+    <%= f.submit t("admin.costs.entries.save"), class: "admin-btn admin-btn--primary admin-btn--sm" %>
+    <%= link_to t("admin.costs.entries.cancel"),
+          admin_costs_path(month: @entry.month&.strftime("%Y-%m")),
+          class: "admin-btn admin-btn--outline admin-btn--sm" %>
+  </div>
+<% end %>

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

@@ -0,0 +1,10 @@
+<% content_for :body_class, "admin-body" %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.costs.entries.edit_title") %></h2>
+  <p class="muted admin-page-sub"><%= @entry.label %> · <%= admin_month_label(@entry.month) %></p>
+</div>
+
+<section class="panel">
+  <%= render "form", url: admin_cost_entry_path(@entry), method: :patch %>
+</section>

backend/app/views/admin/cost_entries/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.costs.entries.new_title") %></h2>
+</div>
+
+<section class="panel">
+  <%= render "form", url: admin_cost_entries_path, method: :post %>
+</section>

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

@@ -0,0 +1,197 @@
+<% content_for :body_class, "admin-body" %>
+<% content_for :head do %>
+  <script>
+    window.adminCostTrend = <%= raw @trend.to_json %>;
+    window.adminCostI18n = {
+      cost: <%= raw t("admin.costs.charts.cost_revenue").to_json %>,
+      revenue: <%= raw t("admin.costs.kpi.revenue").to_json %>,
+      margin: <%= raw t("admin.costs.kpi.margin").to_json %>,
+      costPerHour: <%= raw t("admin.costs.charts.cost_per_hour").to_json %>,
+      hours: <%= raw t("admin.costs.charts.hours").to_json %>
+    };
+  </script>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js" crossorigin="anonymous"></script>
+  <script src="/admin-costs.js?v=1" defer></script>
+<% end %>
+
+<div class="admin-page-head">
+  <h2 class="admin-page-title"><%= t("admin.costs.index.title") %></h2>
+  <p class="muted admin-page-sub"><%= t("admin.costs.index.lead") %></p>
+</div>
+
+<div class="panel admin-sessions-filters">
+  <%= form_with url: admin_costs_path, method: :get, local: true, class: "admin-filter-form" do %>
+    <div class="admin-filter-grid">
+      <label class="admin-filter-field">
+        <span><%= t("admin.costs.index.month") %></span>
+        <%= select_tag :month,
+              options_for_select(
+                @month_options.map { |m| [admin_month_label(m), m.strftime("%Y-%m")] },
+                @month.strftime("%Y-%m")
+              ) %>
+      </label>
+    </div>
+    <div class="admin-filter-actions">
+      <%= submit_tag t("admin.costs.index.apply"), class: "admin-btn admin-btn--primary admin-btn--sm" %>
+      <%= link_to t("admin.costs.index.add_entry"),
+            new_admin_cost_entry_path(month: @month.strftime("%Y-%m")),
+            class: "admin-btn admin-btn--outline admin-btn--sm" %>
+    </div>
+  <% end %>
+</div>
+
+<section class="kpi-grid">
+  <div class="kpi-card kpi-card--accent">
+    <div class="kpi-label"><%= t("admin.costs.kpi.platform_cost") %></div>
+    <div class="kpi-value"><%= format_euros(@summary[:cost_cents]) %></div>
+    <div class="kpi-sub"><%= admin_month_label(@month) %></div>
+  </div>
+  <div class="kpi-card">
+    <div class="kpi-label"><%= t("admin.costs.kpi.revenue") %></div>
+    <div class="kpi-value"><%= format_euros(@summary[:revenue_cents]) %></div>
+    <div class="kpi-sub">
+      <%= t("admin.costs.kpi.margin") %>: <%= format_euros(@summary[:margin_cents]) %>
+      <% if @summary[:margin_pct] %>
+        · <%= @summary[:margin_pct] %>%
+      <% end %>
+    </div>
+  </div>
+  <div class="kpi-card">
+    <div class="kpi-label"><%= t("admin.costs.kpi.cost_per_hour") %></div>
+    <div class="kpi-value"><%= format_euros(@summary[:cost_per_hour_cents]) %></div>
+    <div class="kpi-sub">
+      <%= t("admin.costs.kpi.revenue_per_hour") %>: <%= format_euros(@summary[:revenue_per_hour_cents]) %>
+    </div>
+  </div>
+  <div class="kpi-card">
+    <div class="kpi-label"><%= t("admin.costs.kpi.hours") %></div>
+    <div class="kpi-value"><%= format_hours(@summary[:hours]) %></div>
+    <div class="kpi-sub">
+      <%= t("admin.costs.kpi.sessions") %>: <%= @summary[:sessions] %>
+      · <%= t("admin.costs.kpi.clubs_active") %>: <%= @summary[:clubs_active] %>
+    </div>
+  </div>
+  <div class="kpi-card">
+    <div class="kpi-label"><%= t("admin.costs.kpi.cost_per_session") %></div>
+    <div class="kpi-value"><%= format_euros(@summary[:cost_per_session_cents]) %></div>
+    <div class="kpi-sub"><%= t("admin.costs.kpi.cost_per_club") %>: <%= format_euros(@summary[:cost_per_club_cents]) %></div>
+  </div>
+  <div class="kpi-card">
+    <div class="kpi-label"><%= t("admin.costs.kpi.storage") %></div>
+    <div class="kpi-value" style="font-size:1.2rem"><%= format_bytes(@summary[:storage_bytes]) %></div>
+    <div class="kpi-sub">
+      <%= t("admin.costs.kpi.cost_per_gb") %>: <%= format_euros(@summary[:cost_per_gb_cents]) %>
+      · <%= t("admin.costs.kpi.storage_note") %>
+    </div>
+  </div>
+</section>
+
+<section class="panel" style="margin-bottom:1.25rem">
+  <h3><%= t("admin.costs.index.trends_title") %></h3>
+  <div class="charts-grid">
+    <div class="chart-card">
+      <h3><%= t("admin.costs.charts.cost_revenue") %></h3>
+      <div class="chart-wrap"><canvas id="chart-cost-revenue"></canvas></div>
+    </div>
+    <div class="chart-card">
+      <h3><%= t("admin.costs.charts.cost_per_hour") %></h3>
+      <div class="chart-wrap"><canvas id="chart-cost-hour"></canvas></div>
+    </div>
+    <div class="chart-card">
+      <h3><%= t("admin.costs.charts.hours") %></h3>
+      <div class="chart-wrap"><canvas id="chart-hours"></canvas></div>
+    </div>
+  </div>
+</section>
+
+<section class="panel" style="margin-bottom:1.25rem">
+  <h3><%= t("admin.costs.index.entries_title") %></h3>
+  <p class="muted admin-table-sub"><%= t("admin.costs.index.entries_lead") %></p>
+  <% if @entries.any? %>
+    <div class="admin-table-wrap">
+      <table class="admin-table">
+        <thead>
+          <tr>
+            <th><%= t("admin.costs.table.label") %></th>
+            <th><%= t("admin.costs.table.amount") %></th>
+            <th><%= t("admin.costs.table.notes") %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @entries.each do |entry| %>
+            <tr>
+              <td><strong><%= entry.label %></strong></td>
+              <td><%= format_euros(entry.amount_cents) %></td>
+              <td class="muted"><%= entry.notes.presence || t("admin.common.dash") %></td>
+              <td class="admin-actions">
+                <%= link_to t("admin.announcements.actions.edit"),
+                      edit_admin_cost_entry_path(entry),
+                      class: "admin-btn admin-btn--sm" %>
+                <%= button_to t("admin.costs.entries.delete"),
+                      admin_cost_entry_path(entry),
+                      method: :delete,
+                      class: "admin-btn admin-btn--sm admin-btn--danger",
+                      form: { data: { confirm: t("admin.costs.entries.delete_confirm") } } %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+        <tfoot>
+          <tr>
+            <th><%= t("admin.costs.kpi.platform_cost") %></th>
+            <th><%= format_euros(@summary[:cost_cents]) %></th>
+            <th colspan="2"></th>
+          </tr>
+        </tfoot>
+      </table>
+    </div>
+  <% else %>
+    <p class="empty"><%= t("admin.costs.index.no_entries") %></p>
+  <% end %>
+</section>
+
+<section class="panel">
+  <h3><%= t("admin.costs.index.clubs_title") %></h3>
+  <p class="muted admin-table-sub"><%= t("admin.costs.index.clubs_lead") %></p>
+  <% if @clubs.any? %>
+    <div class="admin-table-wrap">
+      <table class="admin-table">
+        <thead>
+          <tr>
+            <th><%= t("admin.costs.table.club") %></th>
+            <th><%= t("admin.costs.table.plan") %></th>
+            <th><%= t("admin.costs.table.hours") %></th>
+            <th><%= t("admin.costs.table.hours_share") %></th>
+            <th><%= t("admin.costs.table.allocated_cost") %></th>
+            <th><%= t("admin.costs.table.revenue") %></th>
+            <th><%= t("admin.costs.table.margin") %></th>
+            <th><%= t("admin.costs.table.cost_per_hour") %></th>
+            <th><%= t("admin.costs.table.cost_per_session") %></th>
+            <th><%= t("admin.costs.table.storage") %></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @clubs.each do |row| %>
+            <tr>
+              <td>
+                <%= link_to row[:club_name], admin_club_path(row[:club_id]), class: "admin-table-strong" %>
+              </td>
+              <td class="muted"><%= row[:plan_slug] || t("admin.common.dash") %></td>
+              <td><%= format_hours(row[:hours]) %></td>
+              <td class="muted"><%= row[:hours_share_pct] %>%</td>
+              <td><%= format_euros(row[:allocated_cost_cents]) %></td>
+              <td><%= format_euros(row[:revenue_cents]) %></td>
+              <td><%= format_euros(row[:margin_cents]) %></td>
+              <td><%= format_euros(row[:cost_per_hour_cents]) %></td>
+              <td><%= format_euros(row[:cost_per_session_cents]) %></td>
+              <td class="muted"><%= format_bytes(row[:storage_bytes]) %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  <% else %>
+    <p class="empty"><%= t("admin.costs.index.no_clubs") %></p>
+  <% end %>
+</section>

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,9 @@
   <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">
+  <%= yield :head %>
   <% if content_for?(:replay_archive_styles) %>
     <link rel="stylesheet" href="/marketing.css?v=42">
   <% end %>
@@ -25,10 +27,13 @@
         <%= 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.costs"), admin_costs_path, class: ("active" if controller_name.in?(%w[costs cost_entries])) %>
         <%= 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,17 @@
     <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" %>
+    <%= render "shared/analytics_suppress" %>
     <%= 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=77">
   </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 +27,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=5" defer></script>
+    <script src="/cookie-consent.js?v=3" defer></script>
   </body>
 </html>

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

@@ -4,21 +4,25 @@
     <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" %>
+    <%= render "shared/analytics_suppress" %>
     <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=77">
     <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=5" defer></script>
+    <script src="/cookie-consent.js?v=3" 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 %>

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/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/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" %>

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

@@ -1,7 +1,7 @@
 <% content_for :title, t("team.edit.title", name: @team.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><%= @team.name %></h1>
   <p style="color:#888"><%= t("team.edit.club_label") %> <%= link_to @club.name, public_club_path(@club) %></p>
   <div class="card">

backend/app/views/recordings/_club_archive.html.erb

@@ -158,16 +158,16 @@
                     <% end %>
                     <span class="visually-hidden"><%= privacy_label %></span>
                   <% end %>
-                  <% if ent.phone_download_enabled? && rec.ready? %>
+                  <% if ent.phone_download_enabled? && rec.ready? && rec.storage_key.present? %>
                     <%= link_to "MP4", public_replay_download_path(rec.stream_session_id), class: "replay-archive__action replay-archive__action--secondary", title: t("recordings.archive.download_mp4_title") %>
                   <% end %>
-                  <% if ent.premium_full? && ent.youtube_enabled? && rec.ready? && rec.youtube_video_id.blank? %>
+                  <% if ent.premium_full? && ent.youtube_enabled? && rec.ready? && rec.storage_key.present? && rec.youtube_video_id.blank? %>
                     <%= button_to "YT", paths.publish_youtube.call(rec), method: :post, class: "replay-archive__action replay-archive__action--secondary", title: t("recordings.archive.publish_youtube_title"), form: { class: "replay-archive__action-form" } %>
                   <% elsif rec.youtube_watch_url %>
                     <%= link_to "YT", rec.youtube_watch_url, class: "replay-archive__action replay-archive__action--secondary", target: "_blank", rel: "noopener", title: t("recordings.archive.open_youtube_title") %>
                   <% end %>
                   <% has_youtube = rec.youtube_video_id.present? && !rec.youtube_video_id.to_s.start_with?("mock_") %>
-                  <% has_site = rec.storage_key.present? || %w[ready processing failed].include?(rec.status) %>
+                  <% has_site = rec.available_in_archive? || %w[processing failed].include?(rec.status) %>
                   <% delete_confirm = t("recordings.archive.delete_confirm") %>
                   <%= button_to paths.destroy.call(rec), method: :delete,
                       params: filter_params,

backend/app/views/shared/_analytics_suppress.html.erb

@@ -0,0 +1,7 @@
+<% if Analytics::Suppress.active?(request.cookie_jar[Analytics::Suppress::COOKIE_NAME]) %>
+  <meta name="mltv-analytics-suppress" content="1">
+  <div class="mltv-preview-badge" role="status">
+    <span><%= t("ui.analytics_preview.badge") %></span>
+    <%= link_to t("ui.analytics_preview.manage"), admin_analytics_path, class: "mltv-preview-badge__link" %>
+  </div>
+<% end %>

backend/app/views/shared/_cover_fields.html.erb

@@ -1,7 +1,9 @@
 <% record = local_assigns[:record] %>
 <% show_inherit_hint = local_assigns[:show_inherit_hint] %>
 <% can_upload = local_assigns.fetch(:can_upload, false) %>
-<% cover_src = record.effective_cover_url.presence || Streams::CoverResolver::DEFAULT_COVER_URL %>
+<% default_cover = Streams::CoverResolver::DEFAULT_COVER_URL %>
+<% cover_src = record.effective_cover_url.presence || default_cover %>
+<% remove_id = "remove_cover_#{record.model_name.param_key}" %>
 
 <fieldset class="branding-fields cover-fields">
   <legend><%= t("club.branding.cover_legend") %></legend>
@@ -22,16 +24,25 @@
     </div>
 
     <% if can_upload %>
-      <%= file_field_tag "branding[cover_image]",
+      <div class="cover-actions">
-            accept: "image/png,image/jpeg,image/webp",
+        <%= file_field_tag "branding[cover_image]",
-            data: { branding_cover_file: true },
+              accept: "image/png,image/jpeg,image/webp",
-            class: "branding-file-input" %>
+              data: { branding_cover_file: true },
-      <% if record.cover_image_attached? %>
+              class: "branding-file-input" %>
-        <label class="checkbox-label cover-remove-label">
+        <% if record.cover_image_attached? %>
-          <%= check_box_tag "remove_cover", "1", false, id: "remove_cover_#{record.model_name.param_key}" %>
+          <%= hidden_field_tag "remove_cover", "0", id: remove_id, data: { branding_cover_remove: true } %>
-          <%= t("club.branding.cover_remove_label") %>
+          <button type="button"
-        </label>
+                  class="btn btn-secondary cover-reset-btn"
-      <% end %>
+                  data-branding-cover-reset
+                  data-default-cover="<%= default_cover %>"
+                  data-remove-input="#<%= remove_id %>">
+            <%= t("club.branding.cover_reset_button") %>
+          </button>
+          <p class="branding-hint cover-reset-hint" data-branding-cover-reset-hint hidden>
+            <%= t("club.branding.cover_reset_pending_hint") %>
+          </p>
+        <% end %>
+      </div>
     <% else %>
       <p class="muted"><%= t("club.branding.cover_requires_full") %></p>
       <%= link_to t("club.branding.cover_see_plans"), public_prezzi_path, class: "btn btn-secondary btn-sm" %>
@@ -43,13 +54,29 @@
   (function () {
     var input = document.querySelector("[data-branding-cover-file]");
     var img = document.querySelector("[data-branding-cover-img]");
-    if (!input || !img) return;
+    var resetBtn = document.querySelector("[data-branding-cover-reset]");
-    input.addEventListener("change", function () {
+    var removeInput = document.querySelector("[data-branding-cover-remove]");
-      var file = input.files && input.files[0];
+    var resetHint = document.querySelector("[data-branding-cover-reset-hint]");
-      if (!file) return;
+    if (input && img) {
-      var reader = new FileReader();
+      input.addEventListener("change", function () {
-      reader.onload = function (e) { img.src = e.target.result; };
+        var file = input.files && input.files[0];
-      reader.readAsDataURL(file);
+        if (!file) return;
-    });
+        if (removeInput) removeInput.value = "0";
+        if (resetHint) resetHint.hidden = true;
+        if (resetBtn) resetBtn.disabled = false;
+        var reader = new FileReader();
+        reader.onload = function (e) { img.src = e.target.result; };
+        reader.readAsDataURL(file);
+      });
+    }
+    if (resetBtn && img && removeInput) {
+      resetBtn.addEventListener("click", function () {
+        removeInput.value = "1";
+        img.src = resetBtn.getAttribute("data-default-cover");
+        if (input) input.value = "";
+        if (resetHint) resetHint.hidden = false;
+        resetBtn.disabled = true;
+      });
+    }
   })();
 </script>

backend/app/views/shared/_marketing_footer.html.erb

@@ -1,10 +1,10 @@
 <footer class="site-footer">
   <div class="wrap">
-    <div>
+    <div class="site-footer__brand">
       <strong style="color:#fff">Match Live TV</strong> — <%= t("footer.tagline") %>
-      <%= render "shared/store_badges", variant: "footer" %>
     </div>
-    <div>
+    <div class="site-footer__nav">
+      <%= link_to t("common.contacts"), public_contatti_path %> ·
       <%= link_to t("common.support"), public_support_path %> ·
       <%= link_to t("common.pricing"), public_prezzi_path %> ·
       <%= link_to t("footer.live"), public_live_index_path %> ·
@@ -14,6 +14,10 @@
       <%= link_to t("common.terms"), public_termini_path %>
       · <button type="button" class="footer-link-btn" data-cookie-manage><%= t("footer.manage_cookies") %></button>
     </div>
+    <div class="site-footer__apps">
+      <%= render "shared/store_badges", variant: "footer" %>
+      <%= render "shared/social_links", modifier: "footer" %>
+    </div>
     <div class="site-footer__legal">
       <p><%= t("footer.copyright") %></p>
       <p><%= t("footer.responsibility") %></p>

backend/app/views/shared/_marketing_footer_app_store.html.erb

@@ -1,16 +1,19 @@
 <%# Footer minimale per App Store Review: solo link legali/supporto, nessun CTA commerciale. %>
 <footer class="site-footer">
   <div class="wrap">
-    <div>
+    <div class="site-footer__brand">
       <strong style="color:#fff">Match Live TV</strong> — <%= t("footer.tagline") %>
     </div>
-    <div>
+    <div class="site-footer__nav">
       <%= link_to t("common.support"), public_support_path %> ·
       <%= link_to t("common.privacy"), public_privacy_path %> ·
       <%= link_to t("common.cookies"), public_cookies_path %> ·
       <%= link_to t("common.terms"), public_termini_path %>
       · <button type="button" class="footer-link-btn" data-cookie-manage><%= t("footer.manage_cookies") %></button>
     </div>
+    <div class="site-footer__apps">
+      <%= render "shared/social_links", modifier: "footer" %>
+    </div>
     <div class="site-footer__legal">
       <p><%= t("footer.copyright") %></p>
       <p><%= t("footer.responsibility") %></p>

backend/app/views/shared/_site_announcements.html.erb

@@ -0,0 +1,46 @@
+<% announcements = @site_announcements %>
+<% if announcements.present? %>
+  <div class="site-announcements" role="region" aria-label="<%= t("announcement.region") %>">
+    <% announcements.each do |item| %>
+      <article class="site-announcement site-announcement--<%= item.kind %> site-announcement--<%= item.severity %>"
+               data-announcement-id="<%= item.id %>">
+        <div class="site-announcement__body">
+          <p class="site-announcement__title"><%= item.localized_title %></p>
+          <div class="site-announcement__text"><%= simple_format(item.localized_body) %></div>
+          <% action_url = item.resolved_action_url(nil) %>
+          <% if action_url.present? %>
+            <p class="site-announcement__action">
+              <%= link_to (item.localized_action_label.presence || t("announcement.open")), action_url,
+                    class: "site-announcement__link", target: "_blank", rel: "noopener noreferrer" %>
+            </p>
+          <% end %>
+        </div>
+        <% if item.dismissible? %>
+          <button type="button" class="site-announcement__dismiss" data-announcement-dismiss aria-label="<%= t("announcement.dismiss") %>">
+            ×
+          </button>
+        <% end %>
+      </article>
+    <% end %>
+  </div>
+  <script>
+    (function () {
+      var key = "mltv.webDismissedAnnouncements";
+      var dismissed = [];
+      try { dismissed = JSON.parse(localStorage.getItem(key) || "[]"); } catch (e) {}
+      document.querySelectorAll(".site-announcement[data-announcement-id]").forEach(function (el) {
+        if (dismissed.indexOf(el.getAttribute("data-announcement-id")) !== -1) el.remove();
+      });
+      document.querySelectorAll("[data-announcement-dismiss]").forEach(function (btn) {
+        btn.addEventListener("click", function () {
+          var box = btn.closest("[data-announcement-id]");
+          if (!box) return;
+          var id = box.getAttribute("data-announcement-id");
+          if (dismissed.indexOf(id) === -1) dismissed.push(id);
+          localStorage.setItem(key, JSON.stringify(dismissed));
+          box.remove();
+        });
+      });
+    })();
+  </script>
+<% end %>

backend/app/views/shared/_social_links.html.erb

@@ -0,0 +1,41 @@
+<%# Social links: Facebook, Instagram, TikTok, YouTube — glyph brand-color su sfondo trasparente. %>
+<% urls = {
+  facebook: "https://www.facebook.com/matchlivetvapp",
+  instagram: "https://www.instagram.com/matchlivetv_app/",
+  tiktok: "https://www.tiktok.com/@matchlivetv_app",
+  youtube: "https://www.youtube.com/@SportMatchLiveTv"
+} %>
+<% ig_grad_id = "ig-grad-#{SecureRandom.hex(4)}" %>
+<nav class="site-social<%= local_assigns[:modifier].present? ? " site-social--#{modifier}" : "" %>" aria-label="<%= t("footer.social_nav") %>">
+  <a class="site-social__link site-social__link--facebook" href="<%= urls[:facebook] %>" target="_blank" rel="noopener noreferrer" aria-label="<%= t("footer.social_facebook") %>">
+    <svg class="site-social__icon" viewBox="0 0 24 24" width="36" height="36" aria-hidden="true" focusable="false">
+      <path fill="currentColor" d="M14 8.2h2.2V5h-2.2C11.7 5 10 6.8 10 9.2V11H8v3.2h2V19h3.2v-4.8h2.2l.6-3.2h-2.8V9.2c0-.6.4-1 1-1z"/>
+    </svg>
+  </a>
+  <a class="site-social__link site-social__link--instagram" href="<%= urls[:instagram] %>" target="_blank" rel="noopener noreferrer" aria-label="<%= t("footer.social_instagram") %>">
+    <svg class="site-social__icon" viewBox="0 0 24 24" width="36" height="36" aria-hidden="true" focusable="false">
+      <defs>
+        <linearGradient id="<%= ig_grad_id %>" x1="0%" y1="100%" x2="100%" y2="0%">
+          <stop offset="0%" stop-color="#f58529"/>
+          <stop offset="45%" stop-color="#dd2a7b"/>
+          <stop offset="100%" stop-color="#515bd4"/>
+        </linearGradient>
+      </defs>
+      <path fill="url(#<%= ig_grad_id %>)" d="M12 7.2A4.8 4.8 0 1 0 12 16.8 4.8 4.8 0 0 0 12 7.2zm0 7.7a2.9 2.9 0 1 1 0-5.8 2.9 2.9 0 0 1 0 5.8z"/>
+      <circle fill="url(#<%= ig_grad_id %>)" cx="17.4" cy="6.7" r="1.1"/>
+      <path fill="url(#<%= ig_grad_id %>)" d="M12 2.5c-2.6 0-2.9 0-3.9.1-2.6.1-3.9 1.4-4 4-.1 1-.1 1.3-.1 3.9s0 2.9.1 3.9c.1 2.6 1.4 3.9 4 4 1 .1 1.3.1 3.9.1s2.9 0 3.9-.1c2.6-.1 3.9-1.4 4-4 .1-1 .1-1.3.1-3.9s0-2.9-.1-3.9c-.1-2.6-1.4-3.9-4-4-1-.1-1.3-.1-3.9-.1zm0 1.7c2.5 0 2.8 0 3.8.1 1.8.1 2.7.9 2.8 2.8.1 1 .1 1.3.1 3.8s0 2.8-.1 3.8c-.1 1.8-.9 2.7-2.8 2.8-1 .1-1.3.1-3.8.1s-2.8 0-3.8-.1c-1.8-.1-2.7-.9-2.8-2.8-.1-1-.1-1.3-.1-3.8s0-2.8.1-3.8c.1-1.8 1-2.7 2.8-2.8 1-.1 1.3-.1 3.8-.1z"/>
+    </svg>
+  </a>
+  <a class="site-social__link site-social__link--tiktok" href="<%= urls[:tiktok] %>" target="_blank" rel="noopener noreferrer" aria-label="<%= t("footer.social_tiktok") %>">
+    <svg class="site-social__icon" viewBox="0 0 24 24" width="36" height="36" aria-hidden="true" focusable="false">
+      <path fill="#69C9D0" transform="translate(1.15 0.75)" d="M19.1 8.3a5.7 5.7 0 0 1-3.4-1.1v6.2a5.4 5.4 0 1 1-5.4-5.4c.3 0 .5 0 .8.1v2.7a2.7 2.7 0 1 0 1.9 2.6V2.5h2.6a5.7 5.7 0 0 0 3.5 3.4v2.4z"/>
+      <path fill="#EE1D52" transform="translate(-1.15 -0.75)" d="M19.1 8.3a5.7 5.7 0 0 1-3.4-1.1v6.2a5.4 5.4 0 1 1-5.4-5.4c.3 0 .5 0 .8.1v2.7a2.7 2.7 0 1 0 1.9 2.6V2.5h2.6a5.7 5.7 0 0 0 3.5 3.4v2.4z"/>
+      <path fill="#fff" d="M19.1 8.3a5.7 5.7 0 0 1-3.4-1.1v6.2a5.4 5.4 0 1 1-5.4-5.4c.3 0 .5 0 .8.1v2.7a2.7 2.7 0 1 0 1.9 2.6V2.5h2.6a5.7 5.7 0 0 0 3.5 3.4v2.4z"/>
+    </svg>
+  </a>
+  <a class="site-social__link site-social__link--youtube" href="<%= urls[:youtube] %>" target="_blank" rel="noopener noreferrer" aria-label="<%= t("footer.social_youtube") %>">
+    <svg class="site-social__icon" viewBox="0 0 24 24" width="36" height="36" aria-hidden="true" focusable="false">
+      <path fill="currentColor" d="M23.5 7.2a3 3 0 0 0-2.1-2.1C19.5 4.6 12 4.6 12 4.6s-7.5 0-9.4.5A3 3 0 0 0 .5 7.2 31.5 31.5 0 0 0 0 12a31.5 31.5 0 0 0 .5 4.8 3 3 0 0 0 2.1 2.1c1.9.5 9.4.5 9.4.5s7.5 0 9.4-.5a3 3 0 0 0 2.1-2.1A31.5 31.5 0 0 0 24 12a31.5 31.5 0 0 0-.5-4.8zM9.6 15.5v-7l6.3 3.5-6.3 3.5z"/>
+    </svg>
+  </a>
+</nav>

backend/config/initializers/match_live_tv.rb

@@ -1,3 +1,6 @@
+require "net/smtp"
+require "openssl"
+
 module MatchLiveTv
   class << self
     def jwt_secret
@@ -102,6 +105,7 @@ module MatchLiveTv
     end
 
     # In produzione senza SMTP non blocca il flusso (es. collaudo): la mail si può inviare a mano.
+    # Errori SMTP (dominio invalido, EOF Aruba, porta chiusa) non devono far crashare la request.
     def deliver_mail(mail)
       if Rails.env.production? && !smtp_configured?
         Rails.logger.info("[mail] skip (SMTP assente): #{mail.subject}")
@@ -110,6 +114,9 @@ module MatchLiveTv
 
       mail.deliver_now
       true
+    rescue EOFError, Net::SMTPError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError, OpenSSL::SSL::SSLError => e
+      Rails.logger.warn("[mail] delivery failed: #{mail.subject} #{e.class}: #{e.message}")
+      false
     end
 
     def privacy_controller_name
@@ -196,6 +203,24 @@ module MatchLiveTv
       ENV.fetch("REPLAY_MEDIA_REDIRECT", "true") == "true"
     end
 
+    # Retention copia temporanea post-live YouTube (ore). Clamp 24–72, default 48.
+    def youtube_temp_replay_retention_hours
+      raw = ENV.fetch("YOUTUBE_TEMP_REPLAY_RETENTION_HOURS", "48").to_i
+      raw.clamp(24, 72)
+    end
+
+    def youtube_replay_verify_max_attempts
+      ENV.fetch("YOUTUBE_REPLAY_VERIFY_MAX_ATTEMPTS", "12").to_i
+    end
+
+    def youtube_replay_verify_base_interval_secs
+      ENV.fetch("YOUTUBE_REPLAY_VERIFY_BASE_INTERVAL_SECS", "300").to_i
+    end
+
+    def youtube_replay_verify_grace_secs
+      ENV.fetch("YOUTUBE_REPLAY_VERIFY_GRACE_SECS", "120").to_i
+    end
+
     def ops_http_rails_url
       ENV.fetch("OPS_HTTP_RAILS_URL", "http://edge/up")
     end