agroplan-ai-cli 1.0.24 → 1.0.26

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.24",
-  "backend_template_version": "1.0.24",
+  "cli_version": "1.0.26",
+  "backend_template_version": "1.0.26",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -11,7 +11,10 @@
     "hybrid_mode",
     "report_generator_zarc_support",
     "price_provider_index_fallback",
-    "price_display_only"
+    "price_display_only",
+    "price_unit_normalization",
+    "market_profit_estimate",
+    "market_profit_validation"
   ],
-  "generated_at": "2026-05-09T20:00:00Z"
+  "generated_at": "2026-05-09T22:00:00Z"
 }

package/backend-template/api.py

@@ -490,6 +490,96 @@ def get_precos_lote(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/dados/precos/comparar")
+def get_precos_comparar(
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)")
+):
+    """Compara preços originais com preços normalizados para tonelada"""
+    try:
+        from providers.price_provider import buscar_precos_lote
+        from core.price_normalizer import normalizar_precos_lote, obter_estatisticas_normalizacao
+        
+        # Culturas do AgroPlan
+        culturas = ["soja", "milho", "feijao", "trigo", "algodao", "cafe", "cana", "arroz", "sorgo", "mandioca"]
+        
+        # Buscar preços em lote
+        precos_data = buscar_precos_lote(culturas=culturas, uf=uf)
+        
+        # Converter para dict por cultura
+        precos_dict = {p["cultura"]: p for p in precos_data}
+        
+        # Normalizar preços
+        precos_normalizados = normalizar_precos_lote(precos_dict)
+        
+        # Obter estatísticas
+        stats = obter_estatisticas_normalizacao(precos_normalizados)
+        
+        return {
+            "uf": uf,
+            "precos_normalizados": precos_normalizados,
+            "estatisticas": stats
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/debug/lucro-mercado")
+def get_debug_lucro_mercado(
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)"),
+    municipio: Optional[str] = Query(None, description="Município"),
+    safra: str = Query("2025/2026", description="Safra ZARC")
+):
+    """Diagnóstico detalhado do lucro de mercado para validação"""
+    try:
+        from core.loader import carregar_dados
+        from core.planner import gerar_plano_inteligente
+        from core.price_adapter import aplicar_precos_no_plano
+        from core.market_profit_validator import gerar_diagnostico_lucro_mercado
+        
+        # Carregar dados
+        culturas, talhoes, regras = carregar_dados()
+        
+        # Gerar plano inteligente
+        plano_inteligente = gerar_plano_inteligente(culturas, talhoes, regras)
+        
+        # Mapear para formato esperado pelo price_adapter
+        plano = []
+        for item in plano_inteligente:
+            plano.append({
+                'talhao': item['talhao'],
+                'area': item['area'],
+                'solo': item['solo'],
+                'clima': item['clima'],
+                'relevo': item['relevo'],
+                'agua': item['agua'],
+                'cultura': item['cultura_recomendada'],  # Mapear cultura_recomendada -> cultura
+                'lucro_estimado': item['lucro_estimado'],
+                'risco': item['risco'],
+                'nota': item['nota'],
+                'tempo': item['tempo']
+            })
+        
+        resultado = {"plano": plano}
+        
+        # Aplicar preços e normalização
+        resultado = aplicar_precos_no_plano(resultado, uf=uf)
+        
+        # Gerar diagnóstico
+        diagnostico = gerar_diagnostico_lucro_mercado(resultado["plano"], uf=uf)
+        
+        # Adicionar resumo de validação
+        validacao = resultado.get("validacao_lucro_mercado", {})
+        
+        return {
+            "diagnostico": diagnostico,
+            "validacao_resumo": validacao,
+            "municipio": municipio,
+            "safra": safra
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,

package/backend-template/core/market_profit_validator.py

@@ -0,0 +1,266 @@
+"""
+Validador de Lucro de Mercado
+
+Classifica confiabilidade dos valores de lucro de mercado comparando com lucro do sistema.
+Detecta distorções e fornece diagnóstico para validação antes de ativar recálculo automático.
+"""
+
+from typing import Dict, List, Optional
+
+
+def calcular_diferenca_lucro(lucro_sistema: float, lucro_mercado: float) -> Dict:
+    """
+    Calcula diferença entre lucro do sistema e lucro de mercado.
+    
+    Args:
+        lucro_sistema: Lucro calculado com base interna
+        lucro_mercado: Lucro calculado com preços de mercado normalizados
+    
+    Returns:
+        Dict com diferença absoluta, percentual e direção
+    """
+    diferenca_absoluta = lucro_mercado - lucro_sistema
+    
+    # Calcular percentual baseado no valor absoluto do lucro sistema
+    # para evitar divisão por zero e lidar com valores negativos
+    if lucro_sistema != 0:
+        diferenca_percentual = (diferenca_absoluta / abs(lucro_sistema)) * 100
+    else:
+        diferenca_percentual = 0 if lucro_mercado == 0 else float('inf')
+    
+    # Determinar direção
+    if abs(diferenca_percentual) < 5:
+        direcao = "igual"
+    elif diferenca_absoluta > 0:
+        direcao = "maior"
+    else:
+        direcao = "menor"
+    
+    return {
+        "diferenca_absoluta": round(diferenca_absoluta, 2),
+        "diferenca_percentual": round(diferenca_percentual, 2),
+        "direcao": direcao
+    }
+
+
+def classificar_confiabilidade_lucro(item: Dict) -> Dict:
+    """
+    Classifica confiabilidade do lucro de mercado para um item do plano.
+    
+    Args:
+        item: Item do plano com dados de lucro
+    
+    Returns:
+        Dict com confiabilidade (alta/media/baixa) e motivos
+    """
+    motivos = []
+    
+    # Verificar se tem preço normalizado
+    preco_norm = item.get("preco_normalizado", {})
+    if not preco_norm.get("normalizado"):
+        return {
+            "confiabilidade": "baixa",
+            "motivos": ["Preço não normalizado ou não disponível"]
+        }
+    
+    # Verificar se tem produtividade e custo
+    produtividade = item.get("produtividade", 0)
+    custo = item.get("custo", 0)
+    
+    if produtividade <= 0:
+        motivos.append("Produtividade não disponível ou inválida")
+    
+    if custo <= 0:
+        motivos.append("Custo não disponível ou inválido")
+    
+    if motivos:
+        return {
+            "confiabilidade": "baixa",
+            "motivos": motivos
+        }
+    
+    # Verificar se tem lucro de mercado calculado
+    lucro_mercado = item.get("lucro_mercado_estimado")
+    if lucro_mercado is None:
+        return {
+            "confiabilidade": "baixa",
+            "motivos": ["Lucro de mercado não calculado"]
+        }
+    
+    # Calcular diferença com lucro do sistema
+    lucro_sistema = item.get("lucro_estimado", 0)
+    diferenca = calcular_diferenca_lucro(lucro_sistema, lucro_mercado)
+    diferenca_percentual = abs(diferenca["diferenca_percentual"])
+    
+    # Classificar baseado na diferença percentual
+    if diferenca_percentual > 100:
+        confiabilidade = "baixa"
+        motivos.append(f"Diferença muito alta ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+    elif diferenca_percentual > 50:
+        confiabilidade = "media"
+        motivos.append(f"Diferença moderada ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+    else:
+        confiabilidade = "alta"
+        motivos.append(f"Diferença aceitável ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+    
+    # Verificar se lucro de mercado é negativo (prejuízo)
+    if lucro_mercado < 0:
+        if confiabilidade == "alta":
+            confiabilidade = "media"
+        motivos.append("Lucro de mercado indica prejuízo - requer validação de preço/produtividade")
+    
+    # Verificar se é fallback
+    preco_real = item.get("preco_real", {})
+    if preco_real.get("fallback"):
+        if confiabilidade == "alta":
+            confiabilidade = "media"
+        motivos.append("Preço usando fallback (referência) - pode não refletir mercado local")
+    
+    return {
+        "confiabilidade": confiabilidade,
+        "motivos": motivos,
+        "diferenca": diferenca
+    }
+
+
+def validar_plano_lucro_mercado(resultado: Dict) -> Dict:
+    """
+    Valida lucro de mercado para todo o plano e adiciona classificação de confiabilidade.
+    
+    Args:
+        resultado: Resultado do AG ou cenário com plano
+    
+    Returns:
+        Resultado enriquecido com validação de lucro de mercado
+    """
+    if "plano" not in resultado:
+        return resultado
+    
+    # Contadores
+    alta_confiabilidade = 0
+    media_confiabilidade = 0
+    baixa_confiabilidade = 0
+    alertas = []
+    
+    # Validar cada item do plano
+    for item in resultado["plano"]:
+        # Classificar confiabilidade
+        validacao = classificar_confiabilidade_lucro(item)
+        item["validacao_lucro_mercado"] = validacao
+        
+        # Contabilizar
+        conf = validacao["confiabilidade"]
+        if conf == "alta":
+            alta_confiabilidade += 1
+        elif conf == "media":
+            media_confiabilidade += 1
+        else:
+            baixa_confiabilidade += 1
+            # Adicionar alerta para baixa confiabilidade
+            cultura = item.get("cultura", "desconhecida")
+            talhao = item.get("talhao", "?")
+            alertas.append(f"Talhão {talhao} ({cultura}): {', '.join(validacao['motivos'])}")
+    
+    # Adicionar resumo de validação
+    total = len(resultado["plano"])
+    percentual_alta = (alta_confiabilidade / total * 100) if total > 0 else 0
+    percentual_baixa = (baixa_confiabilidade / total * 100) if total > 0 else 0
+    
+    resultado["validacao_lucro_mercado"] = {
+        "ativo": True,
+        "total_itens": total,
+        "itens_alta_confiabilidade": alta_confiabilidade,
+        "itens_media_confiabilidade": media_confiabilidade,
+        "itens_baixa_confiabilidade": baixa_confiabilidade,
+        "percentual_alta_confiabilidade": round(percentual_alta, 1),
+        "percentual_baixa_confiabilidade": round(percentual_baixa, 1),
+        "alertas": alertas[:5],  # Limitar a 5 alertas principais
+        "total_alertas": len(alertas),
+        "recomendacao": _gerar_recomendacao(percentual_alta, percentual_baixa)
+    }
+    
+    return resultado
+
+
+def _gerar_recomendacao(percentual_alta: float, percentual_baixa: float) -> str:
+    """
+    Gera recomendação baseada nos percentuais de confiabilidade.
+    
+    Args:
+        percentual_alta: Percentual de itens com alta confiabilidade
+        percentual_baixa: Percentual de itens com baixa confiabilidade
+    
+    Returns:
+        String com recomendação
+    """
+    if percentual_alta >= 70:
+        return "Lucro de mercado apresenta boa confiabilidade. Considere validação detalhada antes de ativar PRICE_APPLY_TO_PROFIT."
+    elif percentual_baixa >= 50:
+        return "Muitos itens com baixa confiabilidade. Valide preços, produtividades e custos antes de usar lucro de mercado."
+    else:
+        return "Confiabilidade mista. Revise itens com baixa confiabilidade e valide dados de mercado."
+
+
+def gerar_diagnostico_lucro_mercado(plano: List[Dict], uf: Optional[str] = None) -> Dict:
+    """
+    Gera diagnóstico detalhado do lucro de mercado para análise.
+    
+    Args:
+        plano: Lista de itens do plano
+        uf: Unidade Federativa (opcional)
+    
+    Returns:
+        Dict com diagnóstico por cultura
+    """
+    diagnostico = {
+        "uf": uf,
+        "total_culturas": 0,
+        "culturas": {}
+    }
+    
+    # Agrupar por cultura
+    culturas_map = {}
+    for item in plano:
+        cultura = item.get("cultura", "desconhecida")
+        
+        if cultura not in culturas_map:
+            culturas_map[cultura] = []
+        
+        culturas_map[cultura].append(item)
+    
+    # Gerar diagnóstico por cultura
+    for cultura, itens in culturas_map.items():
+        # Calcular médias
+        lucro_sistema_total = sum(i.get("lucro_estimado", 0) for i in itens)
+        lucro_mercado_total = sum(i.get("lucro_mercado_estimado", 0) for i in itens if i.get("lucro_mercado_estimado") is not None)
+        
+        lucro_sistema_medio = lucro_sistema_total / len(itens) if itens else 0
+        lucro_mercado_medio = lucro_mercado_total / len(itens) if itens else 0
+        
+        # Calcular diferença
+        diferenca = calcular_diferenca_lucro(lucro_sistema_medio, lucro_mercado_medio)
+        
+        # Obter confiabilidade do primeiro item (representativo)
+        validacao = classificar_confiabilidade_lucro(itens[0]) if itens else {"confiabilidade": "baixa", "motivos": []}
+        
+        # Obter preço normalizado
+        preco_norm = itens[0].get("preco_normalizado", {}) if itens else {}
+        preco_real = itens[0].get("preco_real", {}) if itens else {}
+        
+        diagnostico["culturas"][cultura] = {
+            "total_talhoes": len(itens),
+            "lucro_sistema_medio": round(lucro_sistema_medio, 2),
+            "lucro_mercado_medio": round(lucro_mercado_medio, 2),
+            "diferenca": diferenca,
+            "confiabilidade": validacao["confiabilidade"],
+            "motivos": validacao["motivos"],
+            "preco_original": preco_real.get("preco"),
+            "unidade_original": preco_real.get("unidade"),
+            "preco_por_tonelada": preco_norm.get("preco_por_tonelada"),
+            "normalizado": preco_norm.get("normalizado", False),
+            "fallback": preco_real.get("fallback", False)
+        }
+    
+    diagnostico["total_culturas"] = len(culturas_map)
+    
+    return diagnostico

package/backend-template/core/price_adapter.py

@@ -1,30 +1,56 @@
 """
 Adaptador de Preços Agrícolas
-Integra preços reais no planejamento
+Integra preços reais no planejamento com normalização de unidades e validação
 """
 
 import os
+import pandas as pd
 from typing import Dict, List, Optional
 from providers.price_provider import buscar_preco, buscar_precos_lote
+from core.price_normalizer import (
+    normalizar_preco_para_tonelada,
+    calcular_lucro_com_preco_normalizado,
+    obter_estatisticas_normalizacao
+)
+from core.market_profit_validator import validar_plano_lucro_mercado
 
 # Configuração
 PRICE_APPLY_TO_PROFIT = os.getenv("PRICE_APPLY_TO_PROFIT", "false").lower() == "true"
 
+# Cache de dados de culturas
+_culturas_cache = None
 
-def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
+def _carregar_culturas():
+    """Carrega dados de culturas do CSV (com cache)"""
+    global _culturas_cache
+    if _culturas_cache is None:
+        _culturas_cache = pd.read_csv("data/culturas.csv")
+    return _culturas_cache
+
+
+def aplicar_precos_no_plano(
+    resultado: Dict, 
+    uf: Optional[str] = None,
+    aplicar_no_lucro: bool = None
+) -> Dict:
     """
-    Aplica informações de preços no plano
+    Aplica informações de preços no plano com normalização de unidades
     
     Args:
         resultado: Resultado do AG ou cenário
         uf: Unidade Federativa (opcional)
+        aplicar_no_lucro: Se True, recalcula lucro com preços. Se None, usa PRICE_APPLY_TO_PROFIT
     
     Returns:
-        Resultado enriquecido com informações de preços
+        Resultado enriquecido com informações de preços e normalização
     """
     if "plano" not in resultado:
         return resultado
     
+    # Determinar se deve aplicar no lucro
+    if aplicar_no_lucro is None:
+        aplicar_no_lucro = PRICE_APPLY_TO_PROFIT
+    
     # Coletar culturas únicas
     culturas = list(set([item.get("cultura") for item in resultado["plano"]]))
     
@@ -38,6 +64,7 @@ def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
     culturas_com_preco = 0
     culturas_fallback = 0
     culturas_sem_preco = 0
+    culturas_normalizadas = 0
     
     # Aplicar preços no plano
     for item in resultado["plano"]:
@@ -47,6 +74,66 @@ def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
         # Adicionar informações de preço
         item["preco_real"] = preco_info
         
+        # Normalizar preço se disponível
+        if preco_info.get("ativo") and preco_info.get("preco") and preco_info.get("unidade"):
+            normalizacao = normalizar_preco_para_tonelada(
+                preco_info["preco"],
+                preco_info["unidade"]
+            )
+            
+            item["preco_normalizado"] = normalizacao
+            
+            if normalizacao.get("normalizado"):
+                culturas_normalizadas += 1
+                
+                # Buscar produtividade e custo da cultura
+                culturas_df = _carregar_culturas()
+                cultura_data = culturas_df[culturas_df['nome'] == cultura]
+                
+                if not cultura_data.empty:
+                    produtividade = float(cultura_data.iloc[0]['produtividade'])  # toneladas/ha
+                    custo = float(cultura_data.iloc[0]['custo'])  # R$/ha
+                    area = item.get("area", 0)  # ha
+                    
+                    # Adicionar campos ao item se não existirem
+                    if "produtividade" not in item:
+                        item["produtividade"] = produtividade
+                    if "custo" not in item:
+                        item["custo"] = custo
+                    
+                    # Calcular lucro de mercado estimado (sempre, independente de aplicar_no_lucro)
+                    if produtividade > 0 and area > 0:
+                        calculo_mercado = calcular_lucro_com_preco_normalizado(
+                            preco_por_tonelada=normalizacao["preco_por_tonelada"],
+                            produtividade=produtividade,
+                            custo_por_hectare=custo,
+                            area=area
+                        )
+                        
+                        item["lucro_mercado_estimado"] = calculo_mercado["lucro_mercado"]
+                        item["lucro_mercado_detalhes"] = calculo_mercado
+                        
+                        # Se aplicar_no_lucro, substituir lucro_estimado
+                        if aplicar_no_lucro:
+                            item["lucro_original"] = item.get("lucro_estimado", 0)
+                            item["lucro_estimado"] = calculo_mercado["lucro_mercado"]
+                            item["lucro_mercado_aplicado"] = True
+                        else:
+                            item["lucro_mercado_aplicado"] = False
+                    else:
+                        item["lucro_mercado_estimado"] = None
+                        item["lucro_mercado_aplicado"] = False
+                else:
+                    item["lucro_mercado_estimado"] = None
+                    item["lucro_mercado_aplicado"] = False
+            else:
+                item["lucro_mercado_estimado"] = None
+                item["lucro_mercado_aplicado"] = False
+        else:
+            item["preco_normalizado"] = {"normalizado": False}
+            item["lucro_mercado_estimado"] = None
+            item["lucro_mercado_aplicado"] = False
+        
         # Contabilizar estatísticas
         if preco_info.get("ativo"):
             if preco_info.get("fallback"):
@@ -55,29 +142,45 @@ def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
                 culturas_com_preco += 1
         else:
             culturas_sem_preco += 1
-        
-        # Se PRICE_APPLY_TO_PROFIT estiver ativo, recalcular lucro
-        # NOTA: Por enquanto, apenas adiciona informação sem recalcular
-        # Recálculo será implementado após validação de unidades
+    
+    # Recalcular lucro_total se aplicar_no_lucro
+    if aplicar_no_lucro:
+        resultado["lucro_total_original"] = resultado.get("lucro_total", 0)
+        resultado["lucro_total"] = sum(
+            item.get("lucro_estimado", 0) for item in resultado["plano"]
+        )
     
     # Adicionar resumo de preços ao resultado
     resultado["precos"] = {
         "ativo": True,
-        "source": "price-local-index",
+        "source": "price-local-index" if culturas_com_preco > 0 else "price-fallback",
         "fallback_count": culturas_fallback,
         "culturas_com_preco": culturas_com_preco,
         "culturas_sem_preco": culturas_sem_preco,
         "total_culturas": len(culturas),
-        "aplicado_no_lucro": PRICE_APPLY_TO_PROFIT,
-        "uf": uf
+        "aplicado_no_lucro": aplicar_no_lucro,
+        "lucro_recalculado_disponivel": any(
+            item.get("lucro_mercado_estimado") is not None 
+            for item in resultado["plano"]
+        ),
+        "uf": uf,
+        "normalizacao": {
+            "ativa": True,
+            "unidade_base": "tonelada",
+            "culturas_normalizadas": culturas_normalizadas,
+            "culturas_nao_normalizadas": len(culturas) - culturas_normalizadas
+        }
     }
     
+    # Validar lucro de mercado e adicionar classificação de confiabilidade
+    resultado = validar_plano_lucro_mercado(resultado)
+    
     return resultado
 
 
 def gerar_secao_precos_relatorio(plano: List[Dict], uf: Optional[str], formato: str = "md") -> str:
     """
-    Gera seção de preços para o relatório
+    Gera seção de preços para o relatório com informações de normalização
     
     Args:
         plano: Lista de itens do plano com informações de preços
@@ -94,8 +197,8 @@ def gerar_secao_precos_relatorio(plano: List[Dict], uf: Optional[str], formato:
             secao += f"**Região:** {uf}\n\n"
         
         secao += "### Preços por Cultura\n\n"
-        secao += "| Cultura | Preço | Unidade | Fonte | Observação |\n"
-        secao += "|---------|-------|---------|-------|------------|\n"
+        secao += "| Cultura | Preço Original | Unidade | Preço/Tonelada | Normalizado | Fonte |\n"
+        secao += "|---------|----------------|---------|----------------|-------------|-------|\n"
         
         # Coletar culturas únicas
         culturas_vistas = set()
@@ -109,27 +212,66 @@ def gerar_secao_precos_relatorio(plano: List[Dict], uf: Optional[str], formato:
             culturas_vistas.add(cultura)
             
             preco_info = item.get("preco_real", {})
+            preco_norm = item.get("preco_normalizado", {})
             
             if preco_info.get("ativo"):
                 preco = preco_info.get("preco")
                 unidade = preco_info.get("unidade", "N/A")
                 fonte = preco_info.get("source", "N/A")
                 fallback_icon = "⚠️ " if preco_info.get("fallback") else ""
-                observacao = preco_info.get("observacao", "")
                 
                 preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
                 
-                secao += f"| {cultura} | {preco_fmt} | {unidade} | {fallback_icon}{fonte} | {observacao} |\n"
+                # Informações de normalização
+                if preco_norm.get("normalizado"):
+                    preco_ton = preco_norm.get("preco_por_tonelada", 0)
+                    preco_ton_fmt = f"R$ {preco_ton:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    norm_status = "✅ Sim"
+                else:
+                    preco_ton_fmt = "N/A"
+                    norm_status = "❌ Não"
+                
+                secao += f"| {cultura} | {preco_fmt} | {unidade} | {preco_ton_fmt} | {norm_status} | {fallback_icon}{fonte} |\n"
             else:
-                secao += f"| {cultura} | N/A | N/A | price-unavailable | Preço não disponível |\n"
+                secao += f"| {cultura} | N/A | N/A | N/A | ❌ Não | price-unavailable |\n"
         
         secao += "\n"
+        
+        # Adicionar informações de lucro de mercado se disponível
+        tem_lucro_mercado = any(item.get("lucro_mercado_estimado") is not None for item in plano)
+        
+        if tem_lucro_mercado:
+            secao += "### Comparação de Lucro\n\n"
+            secao += "| Talhão | Cultura | Lucro Sistema | Lucro Mercado | Diferença |\n"
+            secao += "|--------|---------|---------------|---------------|----------|\n"
+            
+            for item in plano:
+                if item.get("lucro_mercado_estimado") is not None:
+                    talhao = item.get("talhao", "N/A")
+                    cultura = item.get("cultura", "").upper()
+                    lucro_sistema = item.get("lucro_original", item.get("lucro_estimado", 0))
+                    lucro_mercado = item.get("lucro_mercado_estimado", 0)
+                    diferenca = lucro_mercado - lucro_sistema
+                    
+                    lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_fmt = f"R$ {diferenca:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_icon = "📈" if diferenca > 0 else "📉" if diferenca < 0 else "➡️"
+                    
+                    secao += f"| {talhao} | {cultura} | {lucro_sistema_fmt} | {lucro_mercado_fmt} | {diferenca_icon} {diferenca_fmt} |\n"
+            
+            secao += "\n"
+        
         secao += "### Observações\n\n"
         
         if PRICE_APPLY_TO_PROFIT:
-            secao += "✅ **Os preços foram aplicados ao cálculo de lucro estimado.**\n\n"
+            secao += "✅ **Os preços de mercado normalizados foram aplicados ao cálculo de lucro.**\n\n"
         else:
-            secao += "ℹ️ **Os preços são exibidos como referência, mas o cálculo de lucro ainda utiliza a base interna simulada.**\n\n"
+            secao += "ℹ️ **Os preços foram normalizados para R$/tonelada. Nesta versão, o lucro principal ainda usa a base interna do sistema, mas o lucro de mercado estimado é exibido para comparação.**\n\n"
+        
+        secao += "**Normalização de Unidades:**\n"
+        secao += "- Todos os preços foram convertidos para R$/tonelada para permitir comparação consistente\n"
+        secao += "- Fatores de conversão: saca_60kg (×16.67), saca_50kg (×20), arroba_15kg (×66.67)\n\n"
         
         secao += "**Fontes:**\n"
         secao += "- `price-local-index`: Índice local de preços\n"
@@ -156,32 +298,68 @@ def gerar_secao_precos_relatorio(plano: List[Dict], uf: Optional[str], formato:
             culturas_vistas.add(cultura)
             
             preco_info = item.get("preco_real", {})
+            preco_norm = item.get("preco_normalizado", {})
             
             if preco_info.get("ativo"):
                 preco = preco_info.get("preco")
                 unidade = preco_info.get("unidade", "N/A")
                 fonte = preco_info.get("source", "N/A")
                 fallback_text = " (fallback)" if preco_info.get("fallback") else ""
-                observacao = preco_info.get("observacao", "")
                 
                 preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
                 
                 secao += f"  {cultura}:\n"
-                secao += f"    Preço: {preco_fmt}\n"
+                secao += f"    Preço Original: {preco_fmt}\n"
                 secao += f"    Unidade: {unidade}\n"
-                secao += f"    Fonte: {fonte}{fallback_text}\n"
-                secao += f"    Observação: {observacao}\n\n"
+                
+                if preco_norm.get("normalizado"):
+                    preco_ton = preco_norm.get("preco_por_tonelada", 0)
+                    preco_ton_fmt = f"R$ {preco_ton:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    secao += f"    Preço/Tonelada: {preco_ton_fmt}\n"
+                    secao += f"    Normalizado: Sim\n"
+                else:
+                    secao += f"    Normalizado: Não\n"
+                
+                secao += f"    Fonte: {fonte}{fallback_text}\n\n"
             else:
                 secao += f"  {cultura}:\n"
                 secao += f"    Preço: N/A\n"
+                secao += f"    Normalizado: Não\n"
                 secao += f"    Observação: Preço não disponível\n\n"
         
+        # Adicionar comparação de lucro se disponível
+        tem_lucro_mercado = any(item.get("lucro_mercado_estimado") is not None for item in plano)
+        
+        if tem_lucro_mercado:
+            secao += "Comparação de Lucro:\n\n"
+            
+            for item in plano:
+                if item.get("lucro_mercado_estimado") is not None:
+                    talhao = item.get("talhao", "N/A")
+                    cultura = item.get("cultura", "").upper()
+                    lucro_sistema = item.get("lucro_original", item.get("lucro_estimado", 0))
+                    lucro_mercado = item.get("lucro_mercado_estimado", 0)
+                    diferenca = lucro_mercado - lucro_sistema
+                    
+                    lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_fmt = f"R$ {diferenca:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    
+                    secao += f"  Talhão {talhao} ({cultura}):\n"
+                    secao += f"    Lucro Sistema: {lucro_sistema_fmt}\n"
+                    secao += f"    Lucro Mercado: {lucro_mercado_fmt}\n"
+                    secao += f"    Diferença: {diferenca_fmt}\n\n"
+        
         secao += "Observações:\n\n"
         
         if PRICE_APPLY_TO_PROFIT:
-            secao += "Os preços foram aplicados ao cálculo de lucro estimado.\n\n"
+            secao += "Os preços de mercado normalizados foram aplicados ao cálculo de lucro.\n\n"
         else:
-            secao += "Os preços são exibidos como referência, mas o cálculo de lucro ainda utiliza a base interna simulada.\n\n"
+            secao += "Os preços foram normalizados para R$/tonelada. Nesta versão, o lucro principal ainda usa a base interna do sistema, mas o lucro de mercado estimado é exibido para comparação.\n\n"
+        
+        secao += "Normalização de Unidades:\n"
+        secao += "- Todos os preços foram convertidos para R$/tonelada\n"
+        secao += "- Fatores: saca_60kg (x16.67), saca_50kg (x20), arroba_15kg (x66.67)\n\n"
         
         secao += "Fontes:\n"
         secao += "- price-local-index: Índice local de preços\n"

package/backend-template/core/price_normalizer.py

@@ -0,0 +1,182 @@
+"""
+Normalizador de Unidades de Preços Agrícolas
+
+Converte preços de diferentes unidades para uma base comum (R$/tonelada)
+para permitir comparação e cálculo consistente de lucro.
+"""
+
+from typing import Dict, Optional
+
+
+# Fatores de conversão para tonelada
+CONVERSAO_UNIDADES = {
+    "tonelada": 1.0,
+    "saca_60kg": 1000.0 / 60.0,  # 16.6667 sacas por tonelada
+    "saca_50kg": 1000.0 / 50.0,  # 20 sacas por tonelada
+    "arroba_15kg": 1000.0 / 15.0,  # 66.6667 arrobas por tonelada
+}
+
+
+def normalizar_preco_para_tonelada(preco: float, unidade: str) -> Dict:
+    """
+    Converte preço de qualquer unidade para R$/tonelada.
+    
+    Args:
+        preco: Preço na unidade original
+        unidade: Unidade do preço (tonelada, saca_60kg, saca_50kg, arroba_15kg)
+    
+    Returns:
+        Dict com informações de normalização:
+        - preco_original: Preço original
+        - unidade_original: Unidade original
+        - preco_por_tonelada: Preço convertido para R$/tonelada
+        - unidade_normalizada: "tonelada"
+        - fator_conversao: Fator usado na conversão
+        - normalizado: True se conversão foi bem-sucedida
+        - error: Mensagem de erro se conversão falhou
+    """
+    
+    # Normalizar nome da unidade (remover espaços, lowercase)
+    unidade_normalizada = unidade.lower().strip().replace(" ", "_")
+    
+    # Verificar se unidade é suportada
+    if unidade_normalizada not in CONVERSAO_UNIDADES:
+        return {
+            "preco_original": preco,
+            "unidade_original": unidade,
+            "normalizado": False,
+            "error": f"Unidade '{unidade}' não suportada. Unidades válidas: {', '.join(CONVERSAO_UNIDADES.keys())}"
+        }
+    
+    # Obter fator de conversão
+    fator = CONVERSAO_UNIDADES[unidade_normalizada]
+    
+    # Calcular preço por tonelada
+    preco_por_tonelada = preco * fator
+    
+    return {
+        "preco_original": preco,
+        "unidade_original": unidade,
+        "preco_por_tonelada": round(preco_por_tonelada, 2),
+        "unidade_normalizada": "tonelada",
+        "fator_conversao": round(fator, 4),
+        "normalizado": True
+    }
+
+
+def normalizar_precos_lote(precos: Dict[str, Dict]) -> Dict[str, Dict]:
+    """
+    Normaliza preços de múltiplas culturas em lote.
+    
+    Args:
+        precos: Dict com culturas como chave e dados de preço como valor
+    
+    Returns:
+        Dict com culturas como chave e dados normalizados como valor
+    """
+    resultado = {}
+    
+    for cultura, dados_preco in precos.items():
+        if not dados_preco.get("ativo", False):
+            resultado[cultura] = {
+                **dados_preco,
+                "normalizado": False,
+                "error": "Preço não disponível"
+            }
+            continue
+        
+        preco = dados_preco.get("preco")
+        unidade = dados_preco.get("unidade")
+        
+        if preco is None or unidade is None:
+            resultado[cultura] = {
+                **dados_preco,
+                "normalizado": False,
+                "error": "Dados de preço incompletos"
+            }
+            continue
+        
+        # Normalizar preço
+        normalizacao = normalizar_preco_para_tonelada(preco, unidade)
+        
+        # Combinar dados originais com normalização
+        resultado[cultura] = {
+            **dados_preco,
+            **normalizacao
+        }
+    
+    return resultado
+
+
+def calcular_lucro_com_preco_normalizado(
+    preco_por_tonelada: float,
+    produtividade: float,  # toneladas por hectare
+    custo_por_hectare: float,
+    area: float
+) -> Dict:
+    """
+    Calcula lucro usando preço normalizado de mercado.
+    
+    Args:
+        preco_por_tonelada: Preço normalizado em R$/tonelada
+        produtividade: Produtividade em toneladas por hectare
+        custo_por_hectare: Custo de produção por hectare
+        area: Área em hectares
+    
+    Returns:
+        Dict com cálculos detalhados:
+        - receita_total: Receita bruta
+        - custo_total: Custo total de produção
+        - lucro_mercado: Lucro líquido com preço de mercado
+        - lucro_por_hectare: Lucro por hectare
+    """
+    
+    # Calcular receita
+    producao_total = produtividade * area  # toneladas
+    receita_total = preco_por_tonelada * producao_total
+    
+    # Calcular custo
+    custo_total = custo_por_hectare * area
+    
+    # Calcular lucro
+    lucro_mercado = receita_total - custo_total
+    lucro_por_hectare = lucro_mercado / area if area > 0 else 0
+    
+    return {
+        "receita_total": round(receita_total, 2),
+        "custo_total": round(custo_total, 2),
+        "lucro_mercado": round(lucro_mercado, 2),
+        "lucro_por_hectare": round(lucro_por_hectare, 2),
+        "producao_total_toneladas": round(producao_total, 2)
+    }
+
+
+def obter_estatisticas_normalizacao(precos_normalizados: Dict[str, Dict]) -> Dict:
+    """
+    Gera estatísticas sobre normalização de preços.
+    
+    Args:
+        precos_normalizados: Dict com preços normalizados
+    
+    Returns:
+        Dict com estatísticas de normalização
+    """
+    total = len(precos_normalizados)
+    normalizados = sum(1 for p in precos_normalizados.values() if p.get("normalizado", False))
+    nao_normalizados = total - normalizados
+    
+    # Agrupar por unidade original
+    unidades = {}
+    for cultura, dados in precos_normalizados.items():
+        if dados.get("normalizado", False):
+            unidade = dados.get("unidade_original", "desconhecida")
+            unidades[unidade] = unidades.get(unidade, 0) + 1
+    
+    return {
+        "ativa": True,
+        "unidade_base": "tonelada",
+        "total_culturas": total,
+        "culturas_normalizadas": normalizados,
+        "culturas_nao_normalizadas": nao_normalizados,
+        "unidades_originais": unidades
+    }

package/backend-template/core/report_generator.py

@@ -169,6 +169,11 @@ def gerar_relatorio_completo(culturas, talhoes, regras, objetivo='equilibrado',
     secao_precos = gerar_secao_precos_relatorio(resultado_temp["plano"], uf, formato)
     conteudo += "\n\n" + secao_precos
     
+    # Adicionar seção de validação de lucro de mercado
+    if resultado_temp.get("validacao_lucro_mercado", {}).get("ativo"):
+        secao_validacao = gerar_secao_validacao_lucro_mercado(resultado_temp, formato)
+        conteudo += "\n\n" + secao_validacao
+    
     # Salva arquivo
     os.makedirs('reports', exist_ok=True)
     timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
@@ -249,6 +254,193 @@ def gerar_secao_climatica(contexto_climatico, formato='md'):
     return secao
 
 
+def gerar_secao_validacao_lucro_mercado(resultado, formato='md'):
+    """
+    Gera seção de validação de lucro de mercado para o relatório
+    
+    Args:
+        resultado: Resultado com validacao_lucro_mercado
+        formato: 'md' ou 'txt'
+    
+    Returns:
+        String com seção formatada
+    """
+    validacao = resultado.get("validacao_lucro_mercado", {})
+    
+    if not validacao.get("ativo"):
+        return ""
+    
+    if formato == "md":
+        secao = "## 🔍 Validação do Lucro de Mercado\n\n"
+        
+        secao += "### Resumo de Confiabilidade\n\n"
+        
+        total = validacao.get("total_itens", 0)
+        alta = validacao.get("itens_alta_confiabilidade", 0)
+        media = validacao.get("itens_media_confiabilidade", 0)
+        baixa = validacao.get("itens_baixa_confiabilidade", 0)
+        
+        perc_alta = validacao.get("percentual_alta_confiabilidade", 0)
+        perc_baixa = validacao.get("percentual_baixa_confiabilidade", 0)
+        
+        secao += f"- **Total de itens analisados**: {total}\n"
+        secao += f"- **Alta confiabilidade**: {alta} ({perc_alta:.1f}%) 🟢\n"
+        secao += f"- **Média confiabilidade**: {media} ({100 - perc_alta - perc_baixa:.1f}%) 🟡\n"
+        secao += f"- **Baixa confiabilidade**: {baixa} ({perc_baixa:.1f}%) 🔴\n\n"
+        
+        # Recomendação
+        recomendacao = validacao.get("recomendacao", "")
+        if recomendacao:
+            secao += f"**Recomendação**: {recomendacao}\n\n"
+        
+        # Alertas
+        alertas = validacao.get("alertas", [])
+        if alertas:
+            secao += "### ⚠️ Alertas\n\n"
+            for alerta in alertas:
+                secao += f"- {alerta}\n"
+            secao += "\n"
+            
+            total_alertas = validacao.get("total_alertas", 0)
+            if total_alertas > len(alertas):
+                secao += f"*Mostrando {len(alertas)} de {total_alertas} alertas*\n\n"
+        
+        # Detalhes por item
+        secao += "### Detalhes por Talhão\n\n"
+        secao += "| Talhão | Cultura | Lucro Sistema | Lucro Mercado | Diferença % | Confiabilidade |\n"
+        secao += "|--------|---------|---------------|---------------|-------------|----------------|\n"
+        
+        for item in resultado["plano"]:
+            validacao_item = item.get("validacao_lucro_mercado", {})
+            if not validacao_item:
+                continue
+            
+            talhao = item.get("talhao", "N/A")
+            cultura = item.get("cultura", "").upper()
+            lucro_sistema = item.get("lucro_estimado", 0)
+            lucro_mercado = item.get("lucro_mercado_estimado", 0)
+            
+            lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+            
+            if lucro_mercado is not None:
+                lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                diferenca = validacao_item.get("diferenca", {})
+                diferenca_perc = diferenca.get("diferenca_percentual", 0)
+                diferenca_fmt = f"{diferenca_perc:.1f}%"
+            else:
+                lucro_mercado_fmt = "N/A"
+                diferenca_fmt = "N/A"
+            
+            confiabilidade = validacao_item.get("confiabilidade", "baixa")
+            conf_emoji = "🟢" if confiabilidade == "alta" else "🟡" if confiabilidade == "media" else "🔴"
+            conf_label = confiabilidade.title()
+            
+            secao += f"| {talhao} | {cultura} | {lucro_sistema_fmt} | {lucro_mercado_fmt} | {diferenca_fmt} | {conf_emoji} {conf_label} |\n"
+        
+        secao += "\n"
+        
+        # Explicação
+        secao += "### 📊 Sobre a Classificação de Confiabilidade\n\n"
+        secao += "A confiabilidade do lucro de mercado é classificada com base em:\n\n"
+        secao += "- **Alta (🟢)**: Diferença < 50% entre lucro sistema e mercado, preço normalizado disponível\n"
+        secao += "- **Média (🟡)**: Diferença 50-100%, uso de fallback, ou lucro negativo\n"
+        secao += "- **Baixa (🔴)**: Diferença > 100%, dados incompletos, ou preço não disponível\n\n"
+        
+        secao += "### ⚠️ Aviso Importante\n\n"
+        secao += "**O lucro de mercado ainda é experimental e não substitui o lucro principal do sistema.**\n\n"
+        secao += "Os valores são exibidos apenas como comparação para validação. Diferenças altas indicam "
+        secao += "necessidade de validação de produtividade, custos ou unidade comercial.\n\n"
+        secao += "**Status atual**: `PRICE_APPLY_TO_PROFIT=false` (lucro de mercado não afeta otimização)\n"
+        
+    else:  # txt
+        secao = "VALIDAÇÃO DO LUCRO DE MERCADO\n\n"
+        
+        secao += "Resumo de Confiabilidade:\n\n"
+        
+        total = validacao.get("total_itens", 0)
+        alta = validacao.get("itens_alta_confiabilidade", 0)
+        media = validacao.get("itens_media_confiabilidade", 0)
+        baixa = validacao.get("itens_baixa_confiabilidade", 0)
+        
+        perc_alta = validacao.get("percentual_alta_confiabilidade", 0)
+        perc_baixa = validacao.get("percentual_baixa_confiabilidade", 0)
+        
+        secao += f"  Total de itens analisados: {total}\n"
+        secao += f"  Alta confiabilidade: {alta} ({perc_alta:.1f}%)\n"
+        secao += f"  Média confiabilidade: {media} ({100 - perc_alta - perc_baixa:.1f}%)\n"
+        secao += f"  Baixa confiabilidade: {baixa} ({perc_baixa:.1f}%)\n\n"
+        
+        # Recomendação
+        recomendacao = validacao.get("recomendacao", "")
+        if recomendacao:
+            secao += f"Recomendação: {recomendacao}\n\n"
+        
+        # Alertas
+        alertas = validacao.get("alertas", [])
+        if alertas:
+            secao += "Alertas:\n\n"
+            for alerta in alertas:
+                secao += f"  - {alerta}\n"
+            secao += "\n"
+            
+            total_alertas = validacao.get("total_alertas", 0)
+            if total_alertas > len(alertas):
+                secao += f"  (Mostrando {len(alertas)} de {total_alertas} alertas)\n\n"
+        
+        # Detalhes por item
+        secao += "Detalhes por Talhão:\n\n"
+        
+        for item in resultado["plano"]:
+            validacao_item = item.get("validacao_lucro_mercado", {})
+            if not validacao_item:
+                continue
+            
+            talhao = item.get("talhao", "N/A")
+            cultura = item.get("cultura", "").upper()
+            lucro_sistema = item.get("lucro_estimado", 0)
+            lucro_mercado = item.get("lucro_mercado_estimado", 0)
+            
+            lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+            
+            secao += f"  Talhão {talhao} ({cultura}):\n"
+            secao += f"    Lucro Sistema: {lucro_sistema_fmt}\n"
+            
+            if lucro_mercado is not None:
+                lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                diferenca = validacao_item.get("diferenca", {})
+                diferenca_perc = diferenca.get("diferenca_percentual", 0)
+                secao += f"    Lucro Mercado: {lucro_mercado_fmt}\n"
+                secao += f"    Diferença: {diferenca_perc:.1f}%\n"
+            else:
+                secao += f"    Lucro Mercado: N/A\n"
+            
+            confiabilidade = validacao_item.get("confiabilidade", "baixa")
+            secao += f"    Confiabilidade: {confiabilidade.title()}\n"
+            
+            motivos = validacao_item.get("motivos", [])
+            if motivos:
+                secao += f"    Motivos: {', '.join(motivos)}\n"
+            
+            secao += "\n"
+        
+        # Explicação
+        secao += "Sobre a Classificação de Confiabilidade:\n\n"
+        secao += "A confiabilidade do lucro de mercado é classificada com base em:\n\n"
+        secao += "  - Alta: Diferença < 50% entre lucro sistema e mercado\n"
+        secao += "  - Média: Diferença 50-100%, uso de fallback, ou lucro negativo\n"
+        secao += "  - Baixa: Diferença > 100%, dados incompletos, ou preço não disponível\n\n"
+        
+        secao += "Aviso Importante:\n\n"
+        secao += "O lucro de mercado ainda é experimental e não substitui o lucro principal\n"
+        secao += "do sistema. Os valores são exibidos apenas como comparação para validação.\n"
+        secao += "Diferenças altas indicam necessidade de validação de produtividade, custos\n"
+        secao += "ou unidade comercial.\n\n"
+        secao += "Status atual: PRICE_APPLY_TO_PROFIT=false (lucro de mercado não afeta\n"
+        secao += "otimização)\n"
+    
+    return secao
+
+
 def gerar_relatorio_markdown(culturas, talhoes, regras, objetivo, cenarios, resultado_ag, validacao, estabilidade):
     """Gera relatório em formato Markdown"""
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agroplan-ai-cli",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {