agroplan-ai-cli 1.0.24 → 1.0.25

package/backend-template/VERSION.json

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

package/backend-template/api.py

@@ -490,6 +490,39 @@ 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("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,

package/backend-template/core/price_adapter.py

@@ -1,30 +1,55 @@
 """
 Adaptador de Preços Agrícolas
-Integra preços reais no planejamento
+Integra preços reais no planejamento com normalização de unidades
 """
 
 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
+)
 
 # 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 +63,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 +73,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,21 +141,34 @@ 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
+        }
     }
     
     return resultado
@@ -77,7 +176,7 @@ def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
 
 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 +193,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 +208,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 +294,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/package.json

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