agroplan-ai-cli 1.0.28 → 1.0.30

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.28",
-  "backend_template_version": "1.0.28",
+  "cli_version": "1.0.30",
+  "backend_template_version": "1.0.30",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -16,7 +16,9 @@
     "market_profit_estimate",
     "market_profit_validation",
     "market_profit_confidence_refinement",
-    "market_profit_comparative_evaluation"
+    "market_profit_comparative_evaluation",
+    "market_profit_experimental_optimizer",
+    "smart_crop_calendar_engine"
   ],
-  "generated_at": "2026-05-09T23:30:00Z"
+  "generated_at": "2026-05-10T15:30:00Z"
 }

package/backend-template/api.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel
 from typing import Optional
 import sys
 import os
+import uuid
 
 # Adiciona o diretório backend ao path para imports
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -1242,6 +1243,180 @@ def relatorio(request: RelatorioRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/otimizar/lucro-mercado-experimental")
+def otimizar_lucro_mercado_experimental(
+    objetivo: str = Query("mercado", description="Objetivo (sempre 'mercado' para este modo)"),
+    seed: int = Query(42, description="Seed para reprodutibilidade"),
+    geracoes: int = Query(50, 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")
+):
+    """
+    Otimização EXPERIMENTAL usando lucro de mercado como fitness.
+    
+    ATENÇÃO: Este é um modo experimental que:
+    - Usa lucro_mercado_estimado como fitness principal
+    - Bloqueia uso automático se houver itens críticos
+    - NÃO substitui a recomendação principal do sistema
+    - Requer validação manual antes de usar
+    
+    Retorna:
+    - modo: "otimizacao_mercado_experimental"
+    - experimental: true
+    - plano: Plano otimizado por lucro de mercado
+    - bloqueado: true/false
+    - motivo_bloqueio: Razão do bloqueio (se aplicável)
+    - aviso: Texto de aviso sobre natureza experimental
+    """
+    try:
+        from core.market_profit_optimizer import gerar_plano_genetico_lucro_mercado_experimental
+        
+        culturas, talhoes, regras = get_dados()
+        
+        resultado = gerar_plano_genetico_lucro_mercado_experimental(
+            culturas=culturas,
+            talhoes=talhoes,
+            regras=regras,
+            uf=uf,
+            municipio=municipio,
+            safra=safra,
+            objetivo="mercado",  # Força objetivo mercado
+            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 otimização experimental de lucro de mercado."
+            )
+
+@app.post("/planejamento/calendario")
+def gerar_calendario(request: dict):
+    """
+    Gera calendário agrícola para uma cultura.
+    
+    Fase 10.1: Base local para soja, milho e feijão
+    Fase futura: Integração com clima real e replanejamento
+    """
+    try:
+        from core.crop_calendar_engine import gerar_calendario_cultura
+        from core.planning_models import Field, SoilType, Slope, WaterAvailability
+        from datetime import datetime
+        
+        # Validar campos obrigatórios
+        if "cultura" not in request:
+            raise HTTPException(status_code=400, detail="Campo 'cultura' é obrigatório")
+        if "planting_date" not in request:
+            raise HTTPException(status_code=400, detail="Campo 'planting_date' é obrigatório")
+        if "field" not in request:
+            raise HTTPException(status_code=400, detail="Campo 'field' é obrigatório")
+        
+        # Parsear data de plantio
+        try:
+            planting_date = datetime.fromisoformat(request["planting_date"]).date()
+        except Exception:
+            raise HTTPException(status_code=400, detail="Formato de data inválido. Use ISO 8601 (YYYY-MM-DD)")
+        
+        # Criar objeto Field
+        field_data = request["field"]
+        field = Field(
+            id=field_data.get("id", str(uuid.uuid4())),
+            property_id=field_data.get("property_id", "temp"),
+            name=field_data.get("name", "Talhão Temporário"),
+            area_ha=float(field_data.get("area_ha", 10)),
+            soil_type=SoilType(field_data.get("soil_type", "argiloso")),
+            slope=Slope(field_data.get("slope", "plano")),
+            water_availability=WaterAvailability(field_data.get("water_availability", "media"))
+        )
+        
+        # Gerar calendário
+        resultado = gerar_calendario_cultura(
+            cultura=request["cultura"],
+            planting_date=planting_date,
+            field=field,
+            crop_plan_id=request.get("crop_plan_id"),
+            weather_context=request.get("weather_context"),
+            zarc_context=request.get("zarc_context")
+        )
+        
+        return converter_tipos_python(resultado)
+        
+    except HTTPException:
+        raise
+    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 calendário agrícola."
+            )
+
+@app.get("/planejamento/culturas")
+def listar_culturas():
+    """Lista culturas disponíveis no sistema de planejamento"""
+    try:
+        from core.crop_calendar_engine import get_culturas_disponiveis, get_cultura_info
+        
+        culturas = get_culturas_disponiveis()
+        
+        return {
+            "total": len(culturas),
+            "culturas": culturas,
+            "detalhes": {
+                cultura: get_cultura_info(cultura)
+                for cultura in culturas
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/planejamento/culturas/{cultura}")
+def obter_cultura_info(cultura: str):
+    """Obtém informações detalhadas de uma cultura"""
+    try:
+        from core.crop_calendar_engine import get_cultura_info
+        
+        info = get_cultura_info(cultura)
+        
+        if not info:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Cultura '{cultura}' não encontrada"
+            )
+        
+        return info
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.post("/cache/limpar")
 def limpar_cache(request: Request):
     """Limpa o cache de resultados pesados (protegido por token)"""

package/backend-template/core/crop_calendar_engine.py

@@ -0,0 +1,426 @@
+"""
+Engine de Calendário Agrícola
+
+Gera calendários de tarefas para culturas baseado em:
+- Ciclo da cultura
+- Data de plantio
+- Características do talhão
+- Contexto climático (opcional)
+- Contexto ZARC (opcional)
+
+Fase inicial: Base local para soja, milho e feijão
+Fase futura: Integração com clima real e replanejamento
+"""
+
+from datetime import date, timedelta
+from typing import Dict, List, Optional
+import uuid
+
+from .planning_models import (
+    Field, CropCycle, CropPhase, CalendarTask,
+    TaskType, TaskPriority, TaskStatus
+)
+
+
+# Base de Conhecimento Local - Fase 10.1
+
+CROP_CYCLES: Dict[str, Dict] = {
+    "soja": {
+        "cycle_days": 120,
+        "phases": [
+            {
+                "name": "germinacao",
+                "days": 10,
+                "description": "Emergência das plântulas",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar se não houver chuva", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar germinação", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "vegetativa",
+                "days": 40,
+                "description": "Crescimento vegetativo",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "fertilize", "title": "Aplicar fertilizante de cobertura", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar pragas", "priority": "medium", "weather_sensitive": False},
+                    {"type": "irrigate", "title": "Irrigar moderadamente", "priority": "medium", "weather_sensitive": True}
+                ]
+            },
+            {
+                "name": "florescimento",
+                "days": 30,
+                "description": "Floração e formação de vagens",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "inspect_diseases", "title": "Inspecionar doenças", "priority": "high", "weather_sensitive": False},
+                    {"type": "monitor_growth", "title": "Monitorar temperatura", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "enchimento_graos",
+                "days": 30,
+                "description": "Enchimento de grãos",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar maturação", "priority": "high", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "maturacao",
+                "days": 10,
+                "description": "Maturação e secagem",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "harvest", "title": "Preparar colheita", "priority": "high", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar umidade dos grãos", "priority": "medium", "weather_sensitive": False}
+                ]
+            }
+        ],
+        "optimal_temp_min": 20,
+        "optimal_temp_max": 30,
+        "critical_water_phases": ["germinacao", "florescimento", "enchimento_graos"],
+        "harvest_window_days": 15
+    },
+    "milho": {
+        "cycle_days": 140,
+        "phases": [
+            {
+                "name": "germinacao",
+                "days": 12,
+                "description": "Emergência das plântulas",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar se não houver chuva", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar germinação", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "vegetativa",
+                "days": 50,
+                "description": "Crescimento vegetativo",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "fertilize", "title": "Aplicar fertilizante nitrogenado", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar pragas (lagarta)", "priority": "high", "weather_sensitive": False},
+                    {"type": "irrigate", "title": "Irrigar moderadamente", "priority": "medium", "weather_sensitive": True}
+                ]
+            },
+            {
+                "name": "florescimento",
+                "days": 28,
+                "description": "Floração e polinização",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar polinização", "priority": "high", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "enchimento_graos",
+                "days": 40,
+                "description": "Enchimento de grãos",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "inspect_diseases", "title": "Inspecionar doenças foliares", "priority": "high", "weather_sensitive": False},
+                    {"type": "monitor_growth", "title": "Monitorar desenvolvimento das espigas", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "maturacao",
+                "days": 10,
+                "description": "Maturação fisiológica",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "harvest", "title": "Preparar colheita", "priority": "high", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar umidade dos grãos", "priority": "medium", "weather_sensitive": False}
+                ]
+            }
+        ],
+        "optimal_temp_min": 18,
+        "optimal_temp_max": 32,
+        "critical_water_phases": ["germinacao", "florescimento", "enchimento_graos"],
+        "harvest_window_days": 20
+    },
+    "feijao": {
+        "cycle_days": 90,
+        "phases": [
+            {
+                "name": "germinacao",
+                "days": 8,
+                "description": "Emergência das plântulas",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar se não houver chuva", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar germinação", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "vegetativa",
+                "days": 30,
+                "description": "Crescimento vegetativo",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "fertilize", "title": "Aplicar fertilizante de cobertura", "priority": "high", "weather_sensitive": True},
+                    {"type": "inspect_pests", "title": "Inspecionar pragas (vaquinha, mosca-branca)", "priority": "high", "weather_sensitive": False},
+                    {"type": "irrigate", "title": "Irrigar moderadamente", "priority": "medium", "weather_sensitive": True}
+                ]
+            },
+            {
+                "name": "florescimento",
+                "days": 22,
+                "description": "Floração e formação de vagens",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "inspect_diseases", "title": "Inspecionar doenças (antracnose, ferrugem)", "priority": "high", "weather_sensitive": False},
+                    {"type": "monitor_growth", "title": "Monitorar formação de vagens", "priority": "medium", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "enchimento_graos",
+                "days": 20,
+                "description": "Enchimento de grãos",
+                "critical_water": True,
+                "tasks": [
+                    {"type": "irrigate", "title": "Irrigar - fase crítica", "priority": "critical", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar desenvolvimento das vagens", "priority": "high", "weather_sensitive": False}
+                ]
+            },
+            {
+                "name": "maturacao",
+                "days": 10,
+                "description": "Maturação e secagem",
+                "critical_water": False,
+                "tasks": [
+                    {"type": "harvest", "title": "Preparar colheita", "priority": "high", "weather_sensitive": True},
+                    {"type": "monitor_growth", "title": "Monitorar umidade dos grãos", "priority": "medium", "weather_sensitive": False}
+                ]
+            }
+        ],
+        "optimal_temp_min": 18,
+        "optimal_temp_max": 29,
+        "critical_water_phases": ["germinacao", "florescimento", "enchimento_graos"],
+        "harvest_window_days": 10
+    }
+}
+
+
+def get_crop_cycle(cultura: str) -> Optional[CropCycle]:
+    """
+    Retorna o ciclo de uma cultura.
+    
+    Args:
+        cultura: Nome da cultura
+    
+    Returns:
+        CropCycle ou None se cultura não encontrada
+    """
+    if cultura not in CROP_CYCLES:
+        return None
+    
+    cycle_data = CROP_CYCLES[cultura]
+    
+    phases = [
+        CropPhase(
+            name=phase["name"],
+            days=phase["days"],
+            description=phase["description"],
+            critical_water=phase["critical_water"],
+            tasks=[task["type"] for task in phase["tasks"]]
+        )
+        for phase in cycle_data["phases"]
+    ]
+    
+    return CropCycle(
+        culture=cultura,
+        cycle_days=cycle_data["cycle_days"],
+        phases=phases,
+        critical_water_phases=cycle_data["critical_water_phases"],
+        optimal_temp_min=cycle_data["optimal_temp_min"],
+        optimal_temp_max=cycle_data["optimal_temp_max"],
+        harvest_window_days=cycle_data["harvest_window_days"]
+    )
+
+
+def gerar_calendario_cultura(
+    cultura: str,
+    planting_date: date,
+    field: Field,
+    crop_plan_id: Optional[str] = None,
+    weather_context: Optional[Dict] = None,
+    zarc_context: Optional[Dict] = None
+) -> Dict:
+    """
+    Gera calendário de tarefas para uma cultura.
+    
+    Args:
+        cultura: Nome da cultura
+        planting_date: Data de plantio
+        field: Dados do talhão
+        crop_plan_id: ID do plano de cultura (opcional)
+        weather_context: Contexto climático (opcional, fase futura)
+        zarc_context: Contexto ZARC (opcional, fase futura)
+    
+    Returns:
+        Dict com calendário e informações do ciclo
+    """
+    
+    # Verificar se cultura existe
+    if cultura not in CROP_CYCLES:
+        return {
+            "error": f"Cultura '{cultura}' não encontrada",
+            "culturas_disponiveis": list(CROP_CYCLES.keys())
+        }
+    
+    cycle_data = CROP_CYCLES[cultura]
+    crop_plan_id = crop_plan_id or str(uuid.uuid4())
+    
+    # Calcular data estimada de colheita
+    estimated_harvest_date = planting_date + timedelta(days=cycle_data["cycle_days"])
+    
+    # Gerar tarefas
+    tasks = []
+    current_date = planting_date
+    
+    # Tarefa de preparação do solo (7 dias antes do plantio)
+    prepare_date = planting_date - timedelta(days=7)
+    tasks.append(
+        CalendarTask(
+            id=str(uuid.uuid4()),
+            crop_plan_id=crop_plan_id,
+            date=prepare_date,
+            type=TaskType.PREPARE_SOIL,
+            title="Preparar solo para plantio",
+            description=f"Preparar solo {field.soil_type.value} para plantio de {cultura}",
+            priority=TaskPriority.HIGH,
+            source="system",
+            weather_sensitive=False
+        )
+    )
+    
+    # Tarefa de plantio
+    tasks.append(
+        CalendarTask(
+            id=str(uuid.uuid4()),
+            crop_plan_id=crop_plan_id,
+            date=planting_date,
+            type=TaskType.PLANT,
+            title=f"Plantar {cultura}",
+            description=f"Plantio de {cultura} em {field.area_ha} ha",
+            priority=TaskPriority.CRITICAL,
+            source="system",
+            weather_sensitive=True
+        )
+    )
+    
+    # Tarefas por fase
+    for phase in cycle_data["phases"]:
+        phase_start = current_date
+        phase_end = current_date + timedelta(days=phase["days"])
+        
+        # Distribuir tarefas ao longo da fase
+        for i, task_data in enumerate(phase["tasks"]):
+            # Espaçar tarefas uniformemente na fase
+            task_offset = (phase["days"] // (len(phase["tasks"]) + 1)) * (i + 1)
+            task_date = phase_start + timedelta(days=task_offset)
+            
+            tasks.append(
+                CalendarTask(
+                    id=str(uuid.uuid4()),
+                    crop_plan_id=crop_plan_id,
+                    date=task_date,
+                    type=TaskType[task_data["type"].upper()],
+                    title=task_data["title"],
+                    description=f"{task_data['title']} - Fase: {phase['description']}",
+                    priority=TaskPriority[task_data["priority"].upper()],
+                    source="system",
+                    weather_sensitive=task_data["weather_sensitive"]
+                )
+            )
+        
+        current_date = phase_end
+    
+    # Tarefa de colheita
+    tasks.append(
+        CalendarTask(
+            id=str(uuid.uuid4()),
+            crop_plan_id=crop_plan_id,
+            date=estimated_harvest_date,
+            type=TaskType.HARVEST,
+            title=f"Colher {cultura}",
+            description=f"Colheita de {cultura} - Janela de {cycle_data['harvest_window_days']} dias",
+            priority=TaskPriority.CRITICAL,
+            source="system",
+            weather_sensitive=True
+        )
+    )
+    
+    # Ordenar tarefas por data
+    tasks.sort(key=lambda t: t.date)
+    
+    # Montar resposta
+    return {
+        "cultura": cultura,
+        "planting_date": planting_date.isoformat(),
+        "estimated_harvest_date": estimated_harvest_date.isoformat(),
+        "cycle_days": cycle_data["cycle_days"],
+        "field": field.to_dict(),
+        "crop_plan_id": crop_plan_id,
+        "cycle_info": {
+            "optimal_temp_min": cycle_data["optimal_temp_min"],
+            "optimal_temp_max": cycle_data["optimal_temp_max"],
+            "critical_water_phases": cycle_data["critical_water_phases"],
+            "harvest_window_days": cycle_data["harvest_window_days"],
+            "phases": [
+                {
+                    "name": phase["name"],
+                    "days": phase["days"],
+                    "description": phase["description"],
+                    "critical_water": phase["critical_water"]
+                }
+                for phase in cycle_data["phases"]
+            ]
+        },
+        "tasks": [task.to_dict() for task in tasks],
+        "total_tasks": len(tasks),
+        "weather_sensitive_tasks": sum(1 for task in tasks if task.weather_sensitive),
+        "critical_tasks": sum(1 for task in tasks if task.priority == TaskPriority.CRITICAL)
+    }
+
+
+def get_culturas_disponiveis() -> List[str]:
+    """Retorna lista de culturas disponíveis no sistema"""
+    return list(CROP_CYCLES.keys())
+
+
+def get_cultura_info(cultura: str) -> Optional[Dict]:
+    """
+    Retorna informações resumidas de uma cultura.
+    
+    Args:
+        cultura: Nome da cultura
+    
+    Returns:
+        Dict com informações ou None se não encontrada
+    """
+    if cultura not in CROP_CYCLES:
+        return None
+    
+    cycle_data = CROP_CYCLES[cultura]
+    
+    return {
+        "cultura": cultura,
+        "cycle_days": cycle_data["cycle_days"],
+        "optimal_temp_min": cycle_data["optimal_temp_min"],
+        "optimal_temp_max": cycle_data["optimal_temp_max"],
+        "critical_water_phases": cycle_data["critical_water_phases"],
+        "harvest_window_days": cycle_data["harvest_window_days"],
+        "total_phases": len(cycle_data["phases"]),
+        "phases_names": [phase["name"] for phase in cycle_data["phases"]]
+    }

package/backend-template/core/market_profit_optimizer.py

@@ -0,0 +1,158 @@
+"""
+Otimizador Experimental: Algoritmo Genético com Lucro de Mercado
+
+IMPORTANTE: Este é um modo EXPERIMENTAL que não substitui o plano principal.
+Usa lucro de mercado normalizado como fitness, mas bloqueia uso automático
+quando há itens críticos ou baixa confiabilidade.
+
+Status: EXPERIMENTAL - Requer validação manual antes de usar como recomendação.
+"""
+
+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 gerar_plano_genetico_lucro_mercado_experimental(
+    culturas: List[Dict],
+    talhoes: List[Dict],
+    regras: List[Dict],
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    safra: str = "2025/2026",
+    objetivo: str = "mercado",
+    seed: int = 42,
+    geracoes: int = 50,
+    populacao: int = 50
+) -> Dict:
+    """
+    Gera plano otimizado usando lucro de mercado como fitness (EXPERIMENTAL).
+    
+    ATENÇÃO: Este é um modo experimental que:
+    - Usa lucro_mercado_estimado como fitness principal
+    - Aplica penalidade forte para itens sem preço ou baixa confiabilidade
+    - Bloqueia uso automático se houver itens críticos
+    - NÃO substitui a recomendação principal do sistema
+    
+    Args:
+        culturas: Lista de culturas disponíveis
+        talhoes: Lista de talhões
+        regras: Regras de compatibilidade
+        uf: Unidade Federativa (necessário para preços regionais)
+        municipio: Município
+        safra: Safra agrícola
+        objetivo: Sempre "mercado" para este modo
+        seed: Seed para reprodutibilidade
+        geracoes: Número de gerações do AG
+        populacao: Tamanho da população
+    
+    Returns:
+        Dict com plano experimental, validação e status de bloqueio
+    """
+    
+    # Por enquanto, usar o AG normal com objetivo "lucro"
+    # TODO: Implementar fitness customizada baseada em lucro_mercado_estimado
+    resultado = gerar_plano_genetico(
+        culturas=culturas,
+        talhoes=talhoes,
+        regras=regras,
+        objetivo="lucro",  # Usar lucro como proxy por enquanto
+        seed=seed,
+        geracoes=geracoes,
+        populacao=populacao
+    )
+    
+    # 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)
+    
+    # Aplicar preços e normalização
+    resultado = aplicar_precos_no_plano(resultado, uf=uf)
+    
+    # Validar lucro de mercado
+    resultado = validar_plano_lucro_mercado(resultado)
+    
+    # Calcular lucro de mercado total
+    lucro_mercado_total = 0.0
+    lucro_sistema_total = float(resultado.get("lucro_total", 0) or 0)
+    
+    for item in resultado['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:
+                pass
+    
+    # Calcular fitness de mercado (baseado no lucro de mercado)
+    # Normalizar para escala similar ao fitness do sistema
+    fitness_mercado = lucro_mercado_total / 1000000 if lucro_mercado_total > 0 else 0
+    fitness_sistema = float(resultado.get("fitness", 0) or 0)
+    
+    # Obter validação
+    validacao = resultado.get('validacao_lucro_mercado', {}) or {}
+    
+    # Determinar bloqueio
+    itens_criticos = int(validacao.get('itens_criticos', 0) or 0)
+    itens_baixa = int(validacao.get('itens_baixa_confiabilidade', 0) or 0)
+    percentual_alta = float(validacao.get('percentual_alta_confiabilidade', 0) or 0)
+    
+    bloqueado = (
+        itens_criticos > 0
+        or itens_baixa > 0
+        or percentual_alta < 70
+        or lucro_mercado_total <= 0
+    )
+    
+    # Montar motivo de bloqueio
+    motivo_bloqueio = None
+    if bloqueado:
+        motivos = []
+        if itens_criticos > 0:
+            motivos.append(f"{itens_criticos} item(ns) crítico(s)")
+        if itens_baixa > 0:
+            motivos.append(f"{itens_baixa} item(ns) de baixa confiabilidade")
+        if percentual_alta < 70:
+            motivos.append(f"apenas {percentual_alta:.1f}% dos itens têm alta confiabilidade")
+        if lucro_mercado_total <= 0:
+            motivos.append("lucro de mercado total não é positivo")
+        
+        motivo_bloqueio = (
+            "Este plano experimental não deve ser usado como recomendação principal: "
+            + "; ".join(motivos)
+        )
+    
+    # Montar resposta experimental
+    return {
+        "modo": "otimizacao_mercado_experimental",
+        "experimental": True,
+        "aviso": "Este plano é experimental e não substitui a recomendação principal. Validar manualmente antes de usar.",
+        "plano": resultado['plano'],
+        "lucro_mercado_total": float(lucro_mercado_total),
+        "lucro_sistema_total_referencial": float(lucro_sistema_total),
+        "fitness_mercado": float(fitness_mercado),
+        "fitness_sistema_referencial": float(fitness_sistema),
+        "risco_medio": float(resultado.get("risco_medio", 0) or 0),
+        "diversidade": int(resultado.get("diversidade", 0) or 0),
+        "area_total": float(resultado.get("area_total", 0) or 0),
+        "geracoes": int(geracoes),
+        "objetivo": "mercado",
+        "seed": int(seed),
+        "validacao_lucro_mercado": validacao,
+        "bloqueado": bloqueado,
+        "pode_usar_como_recomendacao": not bloqueado,
+        "motivo_bloqueio": motivo_bloqueio,
+        "zarc": resultado.get("zarc"),
+        "precos": resultado.get("precos")
+    }

package/backend-template/core/planning_models.py

@@ -0,0 +1,366 @@
+"""
+Modelos de Domínio para Planejador de Safra Inteligente
+
+Define as entidades principais do sistema de planejamento agrícola:
+- Property: Propriedade rural
+- Field: Talhão/campo
+- CropPlan: Plano de cultura
+- CropCycle: Ciclo da cultura
+- CalendarTask: Tarefa do calendário
+- WeatherAlert: Alerta climático
+- UserObservation: Observação do usuário
+- Intervention: Intervenção/replanejamento
+- PlanningSession: Sessão de planejamento
+"""
+
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from typing import Optional, List, Dict
+from enum import Enum
+
+
+# Enums para tipos padronizados
+
+class SoilType(str, Enum):
+    """Tipos de solo"""
+    ARGILOSO = "argiloso"
+    ARENOSO = "arenoso"
+    MISTO = "misto"
+    SILTOSO = "siltoso"
+
+
+class Slope(str, Enum):
+    """Tipos de relevo"""
+    PLANO = "plano"
+    LEVE = "leve"
+    MEDIO = "medio"
+    INGREME = "ingreme"
+
+
+class WaterAvailability(str, Enum):
+    """Disponibilidade de água"""
+    BAIXA = "baixa"
+    MEDIA = "media"
+    ALTA = "alta"
+
+
+class Objective(str, Enum):
+    """Objetivos de otimização"""
+    EQUILIBRADO = "equilibrado"
+    LUCRO = "lucro"
+    RISCO = "risco"
+    SUSTENTAVEL = "sustentavel"
+
+
+class PlanStatus(str, Enum):
+    """Status do plano de cultura"""
+    PLANNED = "planned"
+    ACTIVE = "active"
+    COMPLETED = "completed"
+    CANCELLED = "cancelled"
+
+
+class TaskType(str, Enum):
+    """Tipos de tarefa"""
+    PREPARE_SOIL = "prepare_soil"
+    PLANT = "plant"
+    IRRIGATE = "irrigate"
+    FERTILIZE = "fertilize"
+    INSPECT_PESTS = "inspect_pests"
+    INSPECT_DISEASES = "inspect_diseases"
+    MONITOR_GROWTH = "monitor_growth"
+    HARVEST = "harvest"
+
+
+class TaskPriority(str, Enum):
+    """Prioridade da tarefa"""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class TaskStatus(str, Enum):
+    """Status da tarefa"""
+    PENDING = "pending"
+    COMPLETED = "completed"
+    SKIPPED = "skipped"
+    RESCHEDULED = "rescheduled"
+
+
+class AlertType(str, Enum):
+    """Tipos de alerta climático"""
+    RAIN = "rain"
+    DROUGHT = "drought"
+    HEAT = "heat"
+    COLD = "cold"
+    FROST = "frost"
+
+
+class AlertSeverity(str, Enum):
+    """Severidade do alerta"""
+    INFO = "info"
+    WARNING = "warning"
+    CRITICAL = "critical"
+
+
+class InterventionReason(str, Enum):
+    """Razão da intervenção"""
+    MISSED_TASK = "missed_task"
+    WEATHER_EVENT = "weather_event"
+    SOIL_CONDITION = "soil_condition"
+    USER_REQUEST = "user_request"
+
+
+class PlanningMode(str, Enum):
+    """Modo de planejamento"""
+    GUIDED = "guided"
+    ADVANCED = "advanced"
+
+
+# Modelos de Domínio
+
+@dataclass
+class Property:
+    """Propriedade rural"""
+    id: str
+    name: str
+    uf: str
+    municipio: str
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "uf": self.uf,
+            "municipio": self.municipio,
+            "lat": self.lat,
+            "lon": self.lon,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat()
+        }
+
+
+@dataclass
+class Field:
+    """Talhão/campo"""
+    id: str
+    property_id: str
+    name: str
+    area_ha: float
+    soil_type: SoilType
+    slope: Slope
+    water_availability: WaterAvailability
+    geometry: Optional[Dict] = None  # GeoJSON para mapa
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "property_id": self.property_id,
+            "name": self.name,
+            "area_ha": self.area_ha,
+            "soil_type": self.soil_type.value,
+            "slope": self.slope.value,
+            "water_availability": self.water_availability.value,
+            "geometry": self.geometry,
+            "created_at": self.created_at.isoformat()
+        }
+
+
+@dataclass
+class CropPlan:
+    """Plano de cultura para um talhão"""
+    id: str
+    field_id: str
+    culture: str
+    planting_date: date
+    estimated_harvest_date: date
+    objective: Objective
+    status: PlanStatus = PlanStatus.PLANNED
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "field_id": self.field_id,
+            "culture": self.culture,
+            "planting_date": self.planting_date.isoformat(),
+            "estimated_harvest_date": self.estimated_harvest_date.isoformat(),
+            "objective": self.objective.value,
+            "status": self.status.value,
+            "created_at": self.created_at.isoformat()
+        }
+
+
+@dataclass
+class CropPhase:
+    """Fase do ciclo da cultura"""
+    name: str
+    days: int
+    description: str
+    critical_water: bool
+    tasks: List[str]
+
+
+@dataclass
+class CropCycle:
+    """Ciclo completo de uma cultura"""
+    culture: str
+    cycle_days: int
+    phases: List[CropPhase]
+    critical_water_phases: List[str]
+    optimal_temp_min: float
+    optimal_temp_max: float
+    harvest_window_days: int
+
+    def to_dict(self) -> Dict:
+        return {
+            "culture": self.culture,
+            "cycle_days": self.cycle_days,
+            "phases": [
+                {
+                    "name": phase.name,
+                    "days": phase.days,
+                    "description": phase.description,
+                    "critical_water": phase.critical_water,
+                    "tasks": phase.tasks
+                }
+                for phase in self.phases
+            ],
+            "critical_water_phases": self.critical_water_phases,
+            "optimal_temp_min": self.optimal_temp_min,
+            "optimal_temp_max": self.optimal_temp_max,
+            "harvest_window_days": self.harvest_window_days
+        }
+
+
+@dataclass
+class CalendarTask:
+    """Tarefa do calendário agrícola"""
+    id: str
+    crop_plan_id: str
+    date: date
+    type: TaskType
+    title: str
+    description: str
+    priority: TaskPriority
+    source: str  # system, user, weather_alert
+    status: TaskStatus = TaskStatus.PENDING
+    weather_sensitive: bool = False
+    completed_at: Optional[datetime] = None
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "crop_plan_id": self.crop_plan_id,
+            "date": self.date.isoformat(),
+            "type": self.type.value,
+            "title": self.title,
+            "description": self.description,
+            "priority": self.priority.value,
+            "source": self.source,
+            "status": self.status.value,
+            "weather_sensitive": self.weather_sensitive,
+            "completed_at": self.completed_at.isoformat() if self.completed_at else None
+        }
+
+
+@dataclass
+class WeatherAlert:
+    """Alerta climático"""
+    id: str
+    crop_plan_id: str
+    date: date
+    alert_type: AlertType
+    severity: AlertSeverity
+    message: str
+    action_suggested: Optional[str] = None
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "crop_plan_id": self.crop_plan_id,
+            "date": self.date.isoformat(),
+            "alert_type": self.alert_type.value,
+            "severity": self.severity.value,
+            "message": self.message,
+            "action_suggested": self.action_suggested,
+            "created_at": self.created_at.isoformat()
+        }
+
+
+@dataclass
+class UserObservation:
+    """Observação do usuário sobre o cultivo"""
+    id: str
+    crop_plan_id: str
+    date: date
+    note: str
+    impact: str  # positive, neutral, negative
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "crop_plan_id": self.crop_plan_id,
+            "date": self.date.isoformat(),
+            "note": self.note,
+            "impact": self.impact,
+            "created_at": self.created_at.isoformat()
+        }
+
+
+@dataclass
+class Intervention:
+    """Intervenção/replanejamento"""
+    id: str
+    crop_plan_id: str
+    reason: InterventionReason
+    suggested_action: str
+    original_task_id: Optional[str] = None
+    new_date: Optional[date] = None
+    risk_adjustment: float = 0.0
+    created_at: datetime = field(default_factory=datetime.now)
+    applied: bool = False
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "crop_plan_id": self.crop_plan_id,
+            "original_task_id": self.original_task_id,
+            "reason": self.reason.value,
+            "suggested_action": self.suggested_action,
+            "new_date": self.new_date.isoformat() if self.new_date else None,
+            "risk_adjustment": self.risk_adjustment,
+            "created_at": self.created_at.isoformat(),
+            "applied": self.applied
+        }
+
+
+@dataclass
+class PlanningSession:
+    """Sessão de planejamento"""
+    id: str
+    property_id: str
+    mode: PlanningMode
+    objective: Objective
+    fields_count: int
+    cultures_recommended: List[str]
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "property_id": self.property_id,
+            "mode": self.mode.value,
+            "objective": self.objective.value,
+            "fields_count": self.fields_count,
+            "cultures_recommended": self.cultures_recommended,
+            "created_at": self.created_at.isoformat()
+        }

package/package.json

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