sequenceDiagram
    participant Client as Cliente/Frontend
    participant DA as Decision API<br/>(/decide)
    participant FS as Feature Service<br/>(/features/customer)
    participant SS as Scoring Service<br/>(/score/*)
    participant PE as Policy Engine
    participant Exec as Executor<br/>(WhatsApp/Email)
    participant DB as MySQL<br/>(core)
    participant Redis as Redis Cache
    participant CH as ClickHouse<br/>(telemetry)
    participant FB as Feedback Worker

    Note over Client,FB: Fluxo: Decisão Completa dos 4 Certos

    %% Requisição inicial
    Client->>DA: POST /decide<br/>{customer_id, org_id}

    %% Feature Service
    DA->>FS: GET /features/customer<br/>{customer_id}
    FS->>Redis: Verifica cache
    alt Cache hit
        Redis-->>FS: Features em cache
    else Cache miss
        FS->>DB: SELECT features de<br/>core_customers, core_orders,<br/>core_interactions
        DB-->>FS: Dados brutos
        FS->>FS: Calcula features derivadas<br/>(recency, frequency, monetary)
        FS->>Redis: Armazena em cache
        FS-->>DA: Features calculadas
    end
    FS-->>DA: Features agregadas

    %% Scoring Service - Intent
    DA->>SS: POST /score/intent<br/>{customer_id, features}
    SS->>SS: Carrega IntentModel<br/>(XGBoost/Logistic Regression)
    SS->>SS: Calcula intent_score<br/>(0.0 - 1.0)
    SS-->>DA: intent_score: 0.85

    %% Scoring Service - Offer
    DA->>SS: POST /score/offer<br/>{customer_id, features, context}
    SS->>DB: SELECT histórico de compras<br/>e estoque disponível
    DB-->>SS: Histórico + estoque
    SS->>SS: Carrega OfferModel<br/>Ranqueia SKUs
    SS->>PE: Verifica políticas<br/>(margem mínima, SKUs foco)
    PE->>DB: SELECT policy_rules<br/>de csuite.policy_rules
    DB-->>PE: Regras de negócio
    PE-->>SS: Constraints aplicadas
    SS-->>DA: offer: {sku, reason, expected_uplift}

    %% Scoring Service - Channel
    DA->>SS: POST /score/channel<br/>{customer_id, features}
    SS->>DB: SELECT histórico de<br/>interações por canal
    DB-->>SS: Taxa de resposta por canal
    SS->>SS: Carrega ChannelModel<br/>Calcula channel_score
    SS-->>DA: channel: "whatsapp"<br/>channel_score: 0.92

    %% Scoring Service - Timing
    DA->>SS: POST /score/timing<br/>{customer_id, features}
    SS->>CH: SELECT histórico de<br/>respostas por horário
    CH-->>SS: Padrões de resposta
    SS->>SS: Carrega TimingModel<br/>(Bandit Algorithm)
    SS-->>DA: send_at: "2024-12-01T14:30:00Z"<br/>confidence: 0.83

    %% Decision Orchestrator
    DA->>DA: Combina scores dos 4 Certos<br/>Aplica guardrails<br/>(opt-out, janela de silêncio)
    DA->>DB: INSERT decision_id em<br/>core_decisions
    DA->>DB: INSERT evento em<br/>core.outbox_events<br/>(tipo: decision_made)
    DA-->>Client: Decision Response<br/>{decision_id, recommendation,<br/>explanations, natural_justification}

    %% Execução (se auto=true)
    alt Auto-execute
        Client->>Exec: POST /send<br/>{decision_id}
        Exec->>DB: SELECT decision details
        DB-->>Exec: Decisão completa
        Exec->>Exec: Gera mensagem personalizada<br/>com base em offer, channel, tone
        Exec->>Exec: Envia via WhatsApp/Email
        Exec->>DB: INSERT interação em<br/>core_interactions
        Exec->>DB: INSERT evento em<br/>core.outbox_events<br/>(tipo: action_executed)
        Exec-->>Client: Action executed
    end

    %% Feedback Loop
    Note over FB,CH: Feedback de Campo (assíncrono)

    FB->>CH: Monitora eventos de feedback<br/>(delivered, read, reply, order)
    CH-->>FB: Eventos de feedback
    FB->>DB: INSERT feedback em<br/>core_feedback
    FB->>DB: INSERT evento em<br/>core.outbox_events<br/>(tipo: feedback_received)
    FB->>SS: Atualiza modelos ML<br/>(retreinamento incremental)

sequenceDiagram
    participant 4C as 4C App<br/>(Decision/Executor)
    participant DB4C as MySQL core<br/>(outbox_events)
    participant Sync as Sync Script<br/>(sync_4c_to_csuite.py)
    participant DBCS as MySQL csuite<br/>(metric_samples,<br/>financial_transactions)
    participant Agent as C-Suite Agent<br/>(CFO/CEO/COO)
    participant Alert as Alert System
    participant Action as Action Items

    Note over 4C,Action: Fluxo: Sincronização 4C → C-Suite

    %% Geração de eventos no 4C
    4C->>DB4C: INSERT em core.outbox_events<br/>(tipo: decision_made)
    4C->>DB4C: INSERT em core.outbox_events<br/>(tipo: action_executed)
    4C->>DB4C: INSERT em core.outbox_events<br/>(tipo: feedback_received)
    4C->>DB4C: INSERT em core.core_orders<br/>(novo pedido)
    4C->>DB4C: INSERT em core.core_feedback<br/>(feedback de campo)

    Note over Sync,DBCS: Sincronização (a cada 5 minutos)

    %% Script de sincronização
    Sync->>DB4C: SELECT * FROM core.outbox_events<br/>WHERE processed = false<br/>ORDER BY created_at
    DB4C-->>Sync: Lista de eventos pendentes

    loop Para cada evento
        alt Tipo: decision_made
            Sync->>Sync: Agrega métricas de decisões<br/>(total hoje, por tipo, por org)
            Sync->>DBCS: INSERT em csuite.metric_samples<br/>{org_id, metric_key, value, timestamp}
        else Tipo: action_executed
            Sync->>Sync: Agrega métricas de ações<br/>(total enviadas, por canal)
            Sync->>DBCS: INSERT em csuite.metric_samples<br/>{org_id, metric_key: "actions_sent", value}
        else Tipo: feedback_received
            Sync->>DB4C: SELECT detalhes do feedback<br/>de core_feedback
            DB4C-->>Sync: Dados do feedback
            Sync->>Sync: Agrega métricas de feedback<br/>(taxa de resposta, conversão)
            Sync->>DBCS: INSERT em csuite.metric_samples<br/>{org_id, metric_key: "response_rate", value}
        end

        Sync->>DB4C: UPDATE core.outbox_events<br/>SET processed = true<br/>WHERE event_id = ?
    end

    %% Sincronização de pedidos
    Sync->>DB4C: SELECT * FROM core.core_orders<br/>WHERE synced_to_csuite = false<br/>AND created_at > last_sync
    DB4C-->>Sync: Novos pedidos

    loop Para cada pedido
        Sync->>DBCS: INSERT em csuite.financial_transactions<br/>{org_id, transaction_type: "order",<br/>amount, order_id, created_at}
        Sync->>DB4C: UPDATE core.core_orders<br/>SET synced_to_csuite = true<br/>WHERE order_id = ?
    end

    Note over Agent,Action: Agentes C-Suite analisam métricas

    %% Agente CFO analisa métricas
    Agent->>DBCS: SELECT métricas financeiras<br/>de csuite.metric_samples<br/>e csuite.financial_transactions
    DBCS-->>Agent: Métricas agregadas

    Agent->>Agent: Analisa tendências<br/>Compara com metas<br/>Detecta anomalias

    alt Anomalia detectada
        Agent->>Alert: Cria alerta<br/>{level: "high", title: "Receita abaixo do esperado"}
        Alert->>DBCS: INSERT em csuite.alerts
    end

    alt Ação necessária
        Agent->>Action: Cria action item<br/>{title: "Revisar estratégia de preços",<br/>priority: "high"}
        Action->>DBCS: INSERT em csuite.action_items
    end

    Agent->>DBCS: INSERT em csuite.agent_runs<br/>{agent_type: "CFO", org_id,<br/>status: "completed", summary}

sequenceDiagram
    participant Cron as Cron/Event<br/>(MySQL Event)
    participant Proc as Procedure<br/>(sp_refresh_revenda_radar)
    participant DB as MySQL<br/>(csuite + context_radar)
    participant Job as Refresh Job<br/>(context-jobs)
    participant MAPI as Manager API<br/>(/manager/today)
    participant Seller as Vendedor/Frontend
    participant DAPI as Decision API<br/>(4C Lite)
    participant Rules as Rules Engine<br/>(escolher_oferta, etc.)

    Note over Cron,Rules: Fluxo: Geração de Tasks Diárias

    %% Trigger do job (diário, 06:00)
    Cron->>Proc: CALL context_radar.sp_refresh_revenda_radar<br/>(CURDATE())

    Note over Proc,DB: Cálculo de Features RFR

    %% Cálculo de features RFR
    Proc->>DB: SELECT revendas de<br/>csuite.core_revendas
    DB-->>Proc: Lista de revendas

    loop Para cada revenda
        Proc->>DB: SELECT pedidos dos últimos 90 dias<br/>de core.core_orders<br/>WHERE revenda_id = ?
        DB-->>Proc: Histórico de pedidos

        Proc->>Proc: Calcula recency_days<br/>(dias desde último pedido)
        Proc->>Proc: Calcula freq_90d<br/>(quantidade de pedidos)
        Proc->>Proc: Calcula revenue_90d<br/>(receita total)
        Proc->>Proc: Calcula score_rfr<br/>(score combinado)
        Proc->>Proc: Classifica class_risco<br/>(baixo, médio, alto)
        Proc->>Proc: Classifica class_valor<br/>(baixo, médio, alto)

        Proc->>DB: INSERT/UPDATE em<br/>context_radar.features_revenda_rfr<br/>{revenda_id, recency_days,<br/>freq_90d, revenue_90d,<br/>score_rfr, class_risco, class_valor}
    end

    Note over Proc,DB: Geração de Tasks

    %% Geração de tasks
    Proc->>DB: SELECT vendedores de<br/>csuite.core_sellers
    DB-->>Proc: Lista de vendedores

    loop Para cada vendedor
        Proc->>DB: SELECT revendas atribuídas<br/>de csuite.core_revendas<br/>WHERE seller_id = ?
        DB-->>Proc: Carteira de revendas

        loop Para cada revenda
            Proc->>DB: SELECT features RFR<br/>de context_radar.features_revenda_rfr<br/>WHERE revenda_id = ?
            DB-->>Proc: Features RFR

            Proc->>Proc: Determina prioridade<br/>(alta: risco alto OU valor alto)<br/>(média: risco médio OU valor médio)<br/>(baixa: outros)
            Proc->>Proc: Determina tipo_acao<br/>(contato: sem pedido há 30+ dias)<br/>(follow-up: pedido recente)
            Proc->>Proc: Determina motivo<br/>("Sem pedido há X dias"<br/>"Receita em declínio")

            Proc->>DB: INSERT em<br/>context_radar.tasks_seller_day<br/>{ref_date, seller_id, revenda_id,<br/>prioridade, tipo_acao, motivo,<br/>status: "pendente"}
        end
    end

    Proc-->>Cron: OK (features e tasks geradas)

    Note over Seller,DAPI: Consulta e Enriquecimento

    %% Vendedor consulta tasks
    Seller->>MAPI: GET /seller/{seller_id}/today<br/>?ref_date=2024-12-01
    MAPI->>DB: SELECT tasks de<br/>context_radar.tasks_seller_day<br/>WHERE seller_id = ? AND ref_date = ?
    DB-->>MAPI: Lista de tasks

    %% Enriquecimento com decisão 4C Lite (opcional)
    alt Task precisa de decisão
        MAPI->>DAPI: POST /4c/decide<br/>{revenda_id: 100}

        DAPI->>DB: SELECT revenda de<br/>csuite.core_revendas<br/>WHERE revenda_id = ?
        DB-->>DAPI: Dados da revenda<br/>{nome, cidade, estado, segmento}

        DAPI->>DB: SELECT features RFR de<br/>context_radar.features_revenda_rfr<br/>WHERE revenda_id = ?
        DB-->>DAPI: Features RFR<br/>{recency_days, freq_90d, revenue_90d,<br/>score_rfr, class_risco, class_valor}

        DAPI->>Rules: escolher_oferta(revenda, features)
        Rules->>Rules: Aplica regras de negócio<br/>Baseado em segmento e features
        Rules-->>DAPI: offer: {sku, reason}

        DAPI->>Rules: sugerir_canal(revenda)
        Rules-->>DAPI: channel: "whatsapp"

        DAPI->>Rules: sugerir_horario()
        Rules-->>DAPI: send_at: null (imediato)

        DAPI->>Rules: gerar_mensagem(revenda, offer)
        Rules->>Rules: Template + personalização<br/>Baseado em nome, cidade, oferta
        Rules-->>DAPI: message: "Olá Revenda ABC..."

        DAPI-->>MAPI: Decision Response<br/>{offer, channel, tone, message, send_at}

        MAPI->>DB: UPDATE context_radar.tasks_seller_day<br/>SET decision_payload = ?<br/>WHERE task_id = ?
    end

    MAPI-->>Seller: Tasks com decisões 4C Lite<br/>{tasks: [{task_id, revenda_nome,<br/>prioridade, decision: {...}}]}