agroplan-ai-cli 1.0.25 → 1.0.27

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.25",
-  "backend_template_version": "1.0.25",
+  "cli_version": "1.0.27",
+  "backend_template_version": "1.0.27",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -13,7 +13,9 @@
     "price_provider_index_fallback",
     "price_display_only",
     "price_unit_normalization",
-    "market_profit_estimate"
+    "market_profit_estimate",
+    "market_profit_validation",
+    "market_profit_confidence_refinement"
   ],
-  "generated_at": "2026-05-09T21:00:00Z"
+  "generated_at": "2026-05-09T23:00:00Z"
 }

package/backend-template/api.py

@@ -523,6 +523,63 @@ def get_precos_comparar(
     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,315 @@
+"""
+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.
+    
+    Critérios refinados (Fase 9.5):
+    - Baixa: diferença >= 150%, dados incompletos, lucro invertido, fallback com diferença >= 100%
+    - Média: diferença 50-150%, fallback, lucro negativo
+    - Alta: diferença < 50%, sem fallback, dados completos
+    
+    Args:
+        item: Item do plano com dados de lucro
+    
+    Returns:
+        Dict com confiabilidade (alta/media/baixa), motivos e flag crítico
+    """
+    motivos = []
+    critico = False
+    
+    # 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"],
+            "critico": True
+        }
+    
+    # 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,
+            "critico": True
+        }
+    
+    # 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"],
+            "critico": True
+        }
+    
+    # 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"])
+    
+    # Verificar se é fallback
+    preco_real = item.get("preco_real", {})
+    is_fallback = preco_real.get("fallback", False)
+    
+    # Verificar inversão de sinal (lucro vira prejuízo ou vice-versa)
+    lucro_invertido = (lucro_sistema > 0 and lucro_mercado < 0) or (lucro_sistema < 0 and lucro_mercado > 0)
+    
+    # CRITÉRIOS REFINADOS (Fase 9.5)
+    
+    # Baixa confiabilidade (crítico)
+    if diferenca_percentual >= 150:
+        confiabilidade = "baixa"
+        motivos.append(f"Diferença extrema ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+        critico = True
+    elif lucro_invertido and lucro_sistema > 0:
+        confiabilidade = "baixa"
+        motivos.append("Lucro do sistema é positivo mas lucro de mercado indica prejuízo")
+        critico = True
+    elif is_fallback and diferenca_percentual >= 100:
+        confiabilidade = "baixa"
+        motivos.append(f"Preço de fallback com diferença muito alta ({diferenca_percentual:.1f}%)")
+        critico = True
+    elif diferenca_percentual >= 100:
+        # Diferença > 100% mesmo sem fallback é baixa confiabilidade
+        confiabilidade = "baixa"
+        motivos.append(f"Diferença muito alta ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+        critico = False  # Não crítico se não for fallback
+    
+    # Média confiabilidade
+    elif diferenca_percentual >= 50:
+        confiabilidade = "media"
+        motivos.append(f"Diferença moderada ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+    elif is_fallback:
+        confiabilidade = "media"
+        motivos.append("Preço de referência (fallback) - pode não refletir mercado local")
+    elif lucro_mercado < 0:
+        confiabilidade = "media"
+        motivos.append("Lucro de mercado indica prejuízo - requer validação")
+    
+    # Alta confiabilidade
+    else:
+        confiabilidade = "alta"
+        motivos.append(f"Diferença aceitável ({diferenca_percentual:.1f}%) entre lucro sistema e mercado")
+        if not is_fallback:
+            motivos.append("Preço real disponível (não fallback)")
+    
+    # Adicionar informação sobre normalização bem-sucedida
+    if preco_norm.get("normalizado") and confiabilidade != "baixa":
+        motivos.append("Unidade comercial normalizada com sucesso")
+    
+    return {
+        "confiabilidade": confiabilidade,
+        "motivos": motivos,
+        "diferenca": diferenca,
+        "critico": critico
+    }
+
+
+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
+    itens_criticos = 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'])}")
+        
+        # Contabilizar itens críticos
+        if validacao.get("critico", False):
+            itens_criticos += 1
+    
+    # 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
+    percentual_critico = (itens_criticos / 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,
+        "itens_criticos": itens_criticos,
+        "percentual_alta_confiabilidade": round(percentual_alta, 1),
+        "percentual_baixa_confiabilidade": round(percentual_baixa, 1),
+        "percentual_critico": round(percentual_critico, 1),
+        "alertas": alertas[:5],  # Limitar a 5 alertas principais
+        "total_alertas": len(alertas),
+        "recomendacao": _gerar_recomendacao(percentual_alta, percentual_baixa, percentual_critico)
+    }
+    
+    return resultado
+
+
+def _gerar_recomendacao(percentual_alta: float, percentual_baixa: float, percentual_critico: float = 0) -> 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
+        percentual_critico: Percentual de itens críticos
+    
+    Returns:
+        String com recomendação
+    """
+    if percentual_critico >= 30:
+        return "Há valores críticos no lucro de mercado. Eles não devem ser usados para otimização sem validação manual."
+    elif 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."
+    elif percentual_critico > 0:
+        return "Alguns valores críticos detectados. Revise itens com baixa confiabilidade 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,6 +1,6 @@
 """
 Adaptador de Preços Agrícolas
-Integra preços reais no planejamento com normalização de unidades
+Integra preços reais no planejamento com normalização de unidades e validação
 """
 
 import os
@@ -12,6 +12,7 @@ from core.price_normalizer import (
     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"
@@ -171,6 +172,9 @@ def aplicar_precos_no_plano(
         }
     }
     
+    # Validar lucro de mercado e adicionar classificação de confiabilidade
+    resultado = validar_plano_lucro_mercado(resultado)
+    
     return resultado
 
 

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,217 @@ 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)
+        criticos = validacao.get("itens_criticos", 0)
+        
+        perc_alta = validacao.get("percentual_alta_confiabilidade", 0)
+        perc_baixa = validacao.get("percentual_baixa_confiabilidade", 0)
+        perc_critico = validacao.get("percentual_critico", 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"
+        
+        if criticos > 0:
+            secao += f"- **⚠️ Itens críticos**: {criticos} ({perc_critico:.1f}%)\n"
+        
+        secao += "\n"
+        
+        # Aviso de itens críticos
+        if criticos > 0:
+            secao += "### ⚠️ ATENÇÃO: Valores Críticos Detectados\n\n"
+            secao += f"**{criticos} item(ns) apresenta(m) valores críticos** que indicam possível desalinhamento entre:\n"
+            secao += "- Preço de mercado vs preço interno\n"
+            secao += "- Produtividade estimada vs real\n"
+            secao += "- Custos operacionais\n"
+            secao += "- Unidade comercial\n\n"
+            secao += "**Estes valores não devem ser usados para otimização sem validação manual.**\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")
+            critico = validacao_item.get("critico", False)
+            
+            if critico:
+                conf_emoji = "⚠️🔴"
+                conf_label = "**CRÍTICO**"
+            else:
+                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-150%, uso de fallback, ou lucro negativo\n"
+        secao += "- **Baixa (🔴)**: Diferença > 150%, dados incompletos, ou preço não disponível\n"
+        secao += "- **⚠️ CRÍTICO**: Diferença extrema (>150%), lucro invertido, ou fallback com diferença >100%\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.25",
+  "version": "1.0.27",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {