agroplan-ai-cli 1.0.26 → 1.0.28

package/backend-template/.env.example

@@ -20,6 +20,10 @@ DATA_MODE=hybrid
 WEATHER_PROVIDER=open-meteo
 PROVIDER_CACHE_TTL=3600
 
+# Debug Configuration
+# Set to true to expose detailed error tracebacks (development only)
+DEBUG_ERRORS=false
+
 # Cache Administration (optional)
 # If set, /cache/limpar endpoint requires X-Cache-Token header
 # Leave empty to disable protection (not recommended for production)

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.26",
-  "backend_template_version": "1.0.26",
+  "cli_version": "1.0.28",
+  "backend_template_version": "1.0.28",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -14,7 +14,9 @@
     "price_display_only",
     "price_unit_normalization",
     "market_profit_estimate",
-    "market_profit_validation"
+    "market_profit_validation",
+    "market_profit_confidence_refinement",
+    "market_profit_comparative_evaluation"
   ],
-  "generated_at": "2026-05-09T22:00:00Z"
+  "generated_at": "2026-05-09T23:30:00Z"
 }

package/backend-template/api.py

@@ -28,6 +28,7 @@ CORS_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:3000,http://127.0.0.1
 DATA_MODE = os.getenv("DATA_MODE", "hybrid")  # simulated, real, hybrid
 WEATHER_PROVIDER = os.getenv("WEATHER_PROVIDER", "open-meteo")
 PROVIDER_CACHE_TTL = int(os.getenv("PROVIDER_CACHE_TTL", "3600"))
+DEBUG_ERRORS = os.getenv("DEBUG_ERRORS", "false").lower() == "true"
 
 # Cache em memória para resultados pesados
 _resultados_cache = {}
@@ -580,6 +581,69 @@ def get_debug_lucro_mercado(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/comparar/lucro-mercado")
+def comparar_lucro_mercado(
+    objetivo: str = Query("equilibrado", description="Objetivo de otimização"),
+    seed: int = Query(42, description="Seed para reprodutibilidade"),
+    geracoes: int = Query(100, description="Número de gerações do AG"),
+    populacao: int = Query(50, description="Tamanho da população"),
+    lat: Optional[float] = Query(None, description="Latitude"),
+    lon: Optional[float] = Query(None, description="Longitude"),
+    days: int = Query(30, description="Dias para análise climática"),
+    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")
+):
+    """
+    Avalia o plano do sistema usando lucro de mercado para comparação.
+    
+    NÃO gera um plano otimizado por mercado. Apenas:
+    1. Gera plano normal com AG usando lucro do sistema
+    2. Avalia esse mesmo plano com lucro de mercado normalizado
+    3. Compara os dois valores de lucro
+    
+    Retorna:
+    - modo: "avaliacao_comparativa"
+    - plano_sistema: Plano otimizado pelo AG normal
+    - avaliacao_mercado: Avaliação do mesmo plano com lucro de mercado
+    - comparacao: Diferenças e validação
+    """
+    try:
+        from core.market_profit_comparator import comparar_plano_sistema_com_avaliacao_mercado
+        
+        culturas, talhoes, regras = get_dados()
+        
+        resultado = comparar_plano_sistema_com_avaliacao_mercado(
+            culturas=culturas,
+            talhoes=talhoes,
+            regras=regras,
+            uf=uf,
+            municipio=municipio,
+            safra=safra,
+            objetivo=objetivo,
+            seed=seed,
+            geracoes=geracoes,
+            populacao=populacao
+        )
+        
+        return converter_tipos_python(resultado)
+        
+    except Exception as e:
+        import traceback
+        if DEBUG_ERRORS:
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                }
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail="Erro ao gerar avaliação comparativa de lucro de mercado."
+            )
+
 @app.get("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,

package/backend-template/core/market_profit_comparator.py

@@ -0,0 +1,171 @@
+"""
+Avaliação Comparativa: Plano Sistema vs Avaliação com Lucro de Mercado
+
+Avalia o plano otimizado pelo sistema usando lucro de mercado normalizado.
+NÃO gera um novo plano otimizado por mercado - apenas avalia o plano atual.
+
+Bloqueia uso automático se houver itens críticos ou baixa confiabilidade.
+"""
+
+from typing import Dict, List, Optional
+from core.planner import gerar_plano_genetico
+from core.price_adapter import aplicar_precos_no_plano
+from core.market_profit_validator import validar_plano_lucro_mercado
+
+
+def comparar_plano_sistema_com_avaliacao_mercado(
+    culturas: List[Dict],
+    talhoes: List[Dict],
+    regras: List[Dict],
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    safra: str = "2025/2026",
+    objetivo: str = "equilibrado",
+    seed: int = 42,
+    geracoes: int = 100,
+    populacao: int = 50
+) -> Dict:
+    """
+    Avalia o plano do sistema usando lucro de mercado para comparação.
+    
+    NÃO gera um plano otimizado por mercado. Apenas:
+    1. Gera plano normal com AG usando lucro do sistema
+    2. Avalia esse mesmo plano com lucro de mercado normalizado
+    3. Compara os dois valores de lucro
+    
+    Args:
+        culturas: Lista de culturas disponíveis
+        talhoes: Lista de talhões
+        regras: Regras de compatibilidade
+        uf: Unidade Federativa
+        municipio: Município
+        safra: Safra agrícola
+        objetivo: Objetivo de otimização
+        seed: Seed para reprodutibilidade
+        geracoes: Número de gerações do AG
+        populacao: Tamanho da população
+    
+    Returns:
+        Dict com modo, plano_sistema, avaliacao_mercado e comparacao
+    """
+    
+    # 1. Gerar plano principal normalmente
+    resultado = gerar_plano_genetico(
+        culturas=culturas,
+        talhoes=talhoes,
+        regras=regras,
+        objetivo=objetivo,
+        seed=seed,
+        geracoes=geracoes,
+        populacao=populacao
+    )
+    
+    # 2. Aplicar ZARC, se houver UF
+    if uf:
+        try:
+            from core.zarc_adapter import enriquecer_plano_com_zarc
+            resultado = enriquecer_plano_com_zarc(
+                resultado,
+                uf=uf,
+                municipio=municipio,
+                safra=safra
+            )
+        except Exception as zarc_error:
+            resultado["zarc_error"] = str(zarc_error)
+    
+    # 3. Aplicar preços
+    # IMPORTANTE: aplicar_precos_no_plano só aceita uf por enquanto
+    resultado = aplicar_precos_no_plano(resultado, uf=uf)
+    
+    # 4. Validar lucro de mercado
+    resultado = validar_plano_lucro_mercado(resultado)
+    
+    plano = resultado.get("plano", [])
+    
+    lucro_sistema_total = float(resultado.get("lucro_total", 0) or 0)
+    
+    lucro_mercado_total = 0.0
+    itens_mercado = []
+    
+    for item in plano:
+        lucro_mercado = item.get("lucro_mercado_estimado")
+        
+        if lucro_mercado is not None:
+            try:
+                lucro_mercado_float = float(lucro_mercado)
+                lucro_mercado_total += lucro_mercado_float
+            except Exception:
+                lucro_mercado_float = None
+        else:
+            lucro_mercado_float = None
+        
+        itens_mercado.append({
+            "talhao": item.get("talhao"),
+            "cultura": item.get("cultura"),
+            "lucro_sistema": item.get("lucro_estimado"),
+            "lucro_mercado_estimado": lucro_mercado_float,
+            "preco_real": item.get("preco_real"),
+            "preco_normalizado": item.get("preco_normalizado"),
+            "validacao_lucro_mercado": item.get("validacao_lucro_mercado")
+        })
+    
+    diferenca_absoluta = lucro_mercado_total - lucro_sistema_total
+    
+    if lucro_sistema_total != 0:
+        diferenca_percentual = (diferenca_absoluta / abs(lucro_sistema_total)) * 100
+    else:
+        diferenca_percentual = 0
+    
+    validacao = resultado.get("validacao_lucro_mercado", {}) or {}
+    
+    total = len(plano)
+    alta = int(validacao.get("itens_alta_confiabilidade", 0) or 0)
+    media = int(validacao.get("itens_media_confiabilidade", 0) or 0)
+    baixa = int(validacao.get("itens_baixa_confiabilidade", 0) or 0)
+    criticos = int(validacao.get("itens_criticos", 0) or 0)
+    
+    percentual_alta = (alta / total * 100) if total else 0
+    
+    pode_usar_mercado = (
+        criticos == 0
+        and baixa == 0
+        and percentual_alta >= 70
+    )
+    
+    motivo_bloqueio = None
+    if not pode_usar_mercado:
+        motivos = []
+        if criticos > 0:
+            motivos.append(f"{criticos} item(ns) crítico(s)")
+        if baixa > 0:
+            motivos.append(f"{baixa} item(ns) de baixa confiabilidade")
+        if percentual_alta < 70:
+            motivos.append(f"apenas {percentual_alta:.1f}% dos itens têm alta confiabilidade")
+        
+        motivo_bloqueio = (
+            "O lucro de mercado não deve ser usado como recomendação principal: "
+            + "; ".join(motivos)
+        )
+    
+    return {
+        "modo": "avaliacao_comparativa",
+        "descricao": "Avalia o plano principal usando lucro de mercado normalizado, sem substituir a recomendação oficial.",
+        "plano_sistema": resultado,
+        "avaliacao_mercado": {
+            "lucro_mercado_total": lucro_mercado_total,
+            "itens": itens_mercado
+        },
+        "comparacao": {
+            "lucro_sistema_total": lucro_sistema_total,
+            "lucro_mercado_total": lucro_mercado_total,
+            "diferenca_absoluta": diferenca_absoluta,
+            "diferenca_percentual": diferenca_percentual,
+            "itens_alta_confiabilidade": alta,
+            "itens_media_confiabilidade": media,
+            "itens_baixa_confiabilidade": baixa,
+            "itens_criticos": criticos,
+            "percentual_alta_confiabilidade": percentual_alta,
+            "pode_usar_mercado": pode_usar_mercado,
+            "motivo_bloqueio": motivo_bloqueio
+        }
+    }

package/backend-template/core/market_profit_validator.py

@@ -47,20 +47,27 @@ 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) e motivos
+        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"]
+            "motivos": ["Preço não normalizado ou não disponível"],
+            "critico": True
         }
     
     # Verificar se tem produtividade e custo
@@ -76,7 +83,8 @@ def classificar_confiabilidade_lucro(item: Dict) -> Dict:
     if motivos:
         return {
             "confiabilidade": "baixa",
-            "motivos": motivos
+            "motivos": motivos,
+            "critico": True
         }
     
     # Verificar se tem lucro de mercado calculado
@@ -84,7 +92,8 @@ def classificar_confiabilidade_lucro(item: Dict) -> Dict:
     if lucro_mercado is None:
         return {
             "confiabilidade": "baixa",
-            "motivos": ["Lucro de mercado não calculado"]
+            "motivos": ["Lucro de mercado não calculado"],
+            "critico": True
         }
     
     # Calcular diferença com lucro do sistema
@@ -92,34 +101,61 @@ def classificar_confiabilidade_lucro(item: Dict) -> Dict:
     diferenca = calcular_diferenca_lucro(lucro_sistema, lucro_mercado)
     diferenca_percentual = abs(diferenca["diferenca_percentual"])
     
-    # Classificar baseado na diferença percentual
-    if diferenca_percentual > 100:
+    # 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")
-    elif diferenca_percentual > 50:
+        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)")
     
-    # 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")
+    # 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
+        "diferenca": diferenca,
+        "critico": critico
     }
 
 
@@ -140,6 +176,7 @@ def validar_plano_lucro_mercado(resultado: Dict) -> Dict:
     alta_confiabilidade = 0
     media_confiabilidade = 0
     baixa_confiabilidade = 0
+    itens_criticos = 0
     alertas = []
     
     # Validar cada item do plano
@@ -160,11 +197,16 @@ def validar_plano_lucro_mercado(resultado: Dict) -> Dict:
             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,
@@ -172,31 +214,38 @@ def validar_plano_lucro_mercado(resultado: Dict) -> Dict:
         "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)
+        "recomendacao": _gerar_recomendacao(percentual_alta, percentual_baixa, percentual_critico)
     }
     
     return resultado
 
 
-def _gerar_recomendacao(percentual_alta: float, percentual_baixa: float) -> str:
+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_alta >= 70:
+    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."
 

package/backend-template/core/report_generator.py

@@ -279,14 +279,31 @@ def gerar_secao_validacao_lucro_mercado(resultado, formato='md'):
         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\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", "")
@@ -332,8 +349,14 @@ def gerar_secao_validacao_lucro_mercado(resultado, formato='md'):
                 diferenca_fmt = "N/A"
             
             confiabilidade = validacao_item.get("confiabilidade", "baixa")
-            conf_emoji = "🟢" if confiabilidade == "alta" else "🟡" if confiabilidade == "media" else "🔴"
-            conf_label = confiabilidade.title()
+            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"
         
@@ -343,8 +366,9 @@ def gerar_secao_validacao_lucro_mercado(resultado, formato='md'):
         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 += "- **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"

package/package.json

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