# Base agent with Foundation integration
defmodule JidoSystem.Agents.FoundationAgent do
  use Jido.Agent
  require Logger
  
  # Auto-register with Foundation on start
  @impl true  
  def on_init(agent) do
    :ok = JidoFoundation.Bridge.register_agent(self(),
      capabilities: agent.schema.capabilities || [],
      metadata: %{
        agent_type: agent.name,
        jido_version: Application.spec(:jido, :vsn),
        foundation_integrated: true
      }
    )
    {:ok, agent}
  end
  
  # Emit telemetry for action execution
  @impl true
  def on_before_action(agent, instruction) do
    JidoFoundation.Bridge.emit_agent_event(self(), :action_starting, 
      %{action: instruction.action}, 
      %{instruction_id: instruction.id}
    )
    {:ok, agent, instruction}
  end
end

# Task processing agent
defmodule JidoSystem.Agents.TaskAgent do
  use JidoSystem.Agents.FoundationAgent,
    name: "task_agent",
    description: "Processes tasks with Foundation infrastructure support",
    actions: [
      JidoSystem.Actions.ProcessTask,
      JidoSystem.Actions.ValidateTask,
      JidoSystem.Actions.CompleteTask
    ],
    capabilities: [:task_processing, :validation, :completion],
    schema: [
      status: [type: :atom, default: :idle],
      processed_count: [type: :integer, default: 0],
      error_count: [type: :integer, default: 0],
      last_task: [type: :map, default: %{}]
    ]
end

# System monitoring agent
defmodule JidoSystem.Agents.MonitorAgent do
  use JidoSystem.Agents.FoundationAgent,
    name: "monitor_agent", 
    description: "Monitors system health and triggers alerts",
    sensors: [
      JidoSystem.Sensors.SystemHealthSensor,
      JidoSystem.Sensors.ResourceUsageSensor
    ],
    capabilities: [:monitoring, :alerting, :health_checks],
    schema: [
      alert_threshold: [type: :float, default: 0.8],
      check_interval: [type: :integer, default: 30_000],
      alerts_sent: [type: :integer, default: 0]
    ]
end

# Multi-agent coordinator
defmodule JidoSystem.Agents.CoordinatorAgent do
  use JidoSystem.Agents.FoundationAgent,
    name: "coordinator_agent",
    description: "Coordinates multiple agents using MABEAM",
    capabilities: [:coordination, :task_distribution, :load_balancing],
    schema: [
      managed_agents: [type: :list, default: []],
      active_tasks: [type: :map, default: %{}],
      coordination_strategy: [type: :atom, default: :round_robin]
    ]
    
  @impl true
  def handle_instruction(%{action: JidoSystem.Actions.DistributeTask} = instruction, agent) do
    # Use Foundation's agent discovery
    {:ok, capable_agents} = JidoFoundation.Bridge.find_agents_by_capability(
      instruction.params.required_capability
    )
    
    # Distribute using MABEAM coordination
    selected_agent = select_best_agent(capable_agents, agent.state.coordination_strategy)
    
    JidoFoundation.Bridge.coordinate_agents(self(), selected_agent, %{
      action: :delegate_task,
      task: instruction.params.task,
      deadline: instruction.params.deadline
    })
    
    {:ok, %{agent | state: update_state(agent.state, selected_agent, instruction)}}
  end
end

# Circuit-breaker protected external API action
defmodule JidoSystem.Actions.CallExternalAPI do
  use Jido.Action,
    name: "call_external_api",
    description: "Makes external API calls with Foundation circuit breaker protection",
    schema: [
      url: [type: :string, required: true],
      method: [type: :atom, default: :get],
      headers: [type: :map, default: %{}],
      body: [type: :any, default: nil],
      timeout: [type: :integer, default: 5000]
    ]

  @impl true
  def run(params, context) do
    service_id = {:external_api, params.url}
    
    JidoFoundation.Bridge.execute_protected(context.agent_pid, fn ->
      HTTPoison.request(params.method, params.url, params.body, params.headers, 
        timeout: params.timeout
      )
    end,
      service_id: service_id,
      fallback: {:error, :service_unavailable},
      timeout: params.timeout
    )
  end
end

# Resource-aware data processing
defmodule JidoSystem.Actions.ProcessLargeDataset do
  use Jido.Action,
    name: "process_large_dataset",
    description: "Processes large datasets with resource management",
    schema: [
      dataset: [type: :any, required: true],
      chunk_size: [type: :integer, default: 1000],
      processing_type: [type: :atom, required: true]
    ]

  @impl true
  def run(params, context) do
    # Acquire computational resources
    case JidoFoundation.Bridge.acquire_resource(:heavy_computation, %{
      agent: context.agent_pid,
      estimated_size: length(params.dataset)
    }) do
      {:ok, resource_token} ->
        try do
          result = process_with_chunks(params.dataset, params.chunk_size, params.processing_type)
          {:ok, result}
        after
          JidoFoundation.Bridge.release_resource(resource_token)
        end
        
      {:error, :resource_exhausted} ->
        # Retry with smaller chunks
        smaller_chunks = div(params.chunk_size, 2)
        if smaller_chunks > 0 do
          run(%{params | chunk_size: smaller_chunks}, context)
        else
          {:error, :insufficient_resources}
        end
    end
  end
end

# Multi-step workflow with compensation
defmodule JidoSystem.Actions.ComplexWorkflow do
  use Jido.Action,
    name: "complex_workflow",
    description: "Multi-step workflow with rollback capabilities",
    schema: [
      steps: [type: :list, required: true],
      rollback_on_error: [type: :boolean, default: true],
      continue_on_partial_failure: [type: :boolean, default: false]
    ]

  @impl true  
  def run(params, context) do
    with {:ok, results} <- execute_steps(params.steps, context, []),
         {:ok, validated} <- validate_results(results) do
      {:ok, %{
        results: validated,
        steps_completed: length(params.steps),
        status: :success
      }}
    else
      {:error, {step_index, reason, partial_results}} when params.rollback_on_error ->
        {:ok, _} = rollback_steps(step_index, partial_results, context)
        {:error, %{reason: reason, step: step_index, rollback_completed: true}}
        
      {:error, reason} ->
        {:error, reason}
    end
  end
  
  def compensate(result, params, context) do
    # Jido compensation hook for cleanup
    if result.rollback_completed do
      Logger.info("Workflow #{context.instruction_id} rolled back successfully")
    end
    :ok
  end
end

# System health monitoring
defmodule JidoSystem.Sensors.SystemHealthSensor do
  use Jido.Sensor,
    name: "system_health_sensor",
    description: "Monitors system health metrics",
    schema: [
      memory_threshold: [type: :float, default: 0.8],
      cpu_threshold: [type: :float, default: 0.8], 
      check_interval: [type: :integer, default: 10_000]
    ]

  @impl true
  def deliver_signal(state) do
    health_data = %{
      memory_usage: get_memory_usage(),
      cpu_usage: get_cpu_usage(),
      disk_usage: get_disk_usage(),
      process_count: length(Process.list()),
      timestamp: DateTime.utc_now()
    }
    
    alert_level = determine_alert_level(health_data, state.config)
    
    signal_type = case alert_level do
      :critical -> "system.health.critical"
      :warning -> "system.health.warning"  
      :normal -> "system.health.normal"
    end
    
    {:ok, Jido.Signal.new(%{
      source: "#{state.sensor.name}:#{state.id}",
      type: signal_type,
      data: health_data
    })}
  end
end

# Database performance sensor
defmodule JidoSystem.Sensors.DatabaseSensor do
  use Jido.Sensor,
    name: "database_sensor", 
    description: "Monitors database performance and connectivity",
    schema: [
      connection_pool: [type: :atom, required: true],
      query_timeout_threshold: [type: :integer, default: 5000],
      slow_query_threshold: [type: :integer, default: 1000]
    ]

  @impl true
  def deliver_signal(state) do
    db_metrics = %{
      connection_count: get_connection_count(state.config.connection_pool),
      avg_query_time: get_avg_query_time(),
      slow_queries: get_slow_query_count(state.config.slow_query_threshold),
      failed_queries: get_failed_query_count(),
      pool_overflow: check_pool_overflow(state.config.connection_pool)
    }
    
    {:ok, Jido.Signal.new(%{
      source: "#{state.sensor.name}:#{state.id}",
      type: "database.metrics",
      data: db_metrics
    })}
  end
end

# E-commerce order processing workflow
defmodule JidoSystem.Workflows.OrderProcessingFlow do
  use Jido.Workflow,
    name: "order_processing_flow",
    description: "Complete order processing from validation to fulfillment"

  def define_flow do
    [
      # Step 1: Validate order
      %{
        name: :validate_order,
        action: JidoSystem.Actions.ValidateOrder,
        timeout: 5_000,
        required: true,
        on_error: :halt
      },
      
      # Step 2: Check inventory (parallel with payment)
      %{
        name: :check_inventory,
        action: JidoSystem.Actions.CheckInventory,
        timeout: 10_000,
        parallel_group: :validation,
        on_error: :retry
      },
      
      # Step 3: Process payment (parallel with inventory)
      %{
        name: :process_payment,
        action: JidoSystem.Actions.ProcessPayment,
        timeout: 15_000,
        parallel_group: :validation,
        compensation: JidoSystem.Actions.RefundPayment,
        on_error: :compensate
      },
      
      # Step 4: Reserve inventory (requires both previous steps)
      %{
        name: :reserve_inventory,
        action: JidoSystem.Actions.ReserveInventory,
        depends_on: [:check_inventory, :process_payment],
        timeout: 5_000,
        compensation: JidoSystem.Actions.ReleaseInventory
      },
      
      # Step 5: Create shipment
      %{
        name: :create_shipment,
        action: JidoSystem.Actions.CreateShipment,
        depends_on: [:reserve_inventory],
        timeout: 10_000,
        async: true  # Can continue without waiting
      },
      
      # Step 6: Send confirmation
      %{
        name: :send_confirmation,
        action: JidoSystem.Actions.SendConfirmation,
        depends_on: [:process_payment],
        timeout: 5_000,
        on_error: :continue  # Non-critical step
      }
    ]
  end
  
  def run(order_data, context) do
    # Enhanced workflow execution with Foundation integration
    workflow_id = "order_#{order_data.id}_#{System.unique_integer()}"
    
    # Register workflow with Foundation for monitoring
    :ok = JidoFoundation.Bridge.register_agent(self(),
      capabilities: [:workflow_execution, :order_processing],
      metadata: %{
        workflow_id: workflow_id,
        order_id: order_data.id,
        started_at: DateTime.utc_now()
      }
    )
    
    try do
      result = execute_workflow(define_flow(), order_data, context)
      
      # Emit completion telemetry
      JidoFoundation.Bridge.emit_agent_event(self(), :workflow_completed,
        %{duration_ms: calculate_duration(context.started_at)},
        %{workflow_id: workflow_id, success: elem(result, 0) == :ok}
      )
      
      result
    after
      JidoFoundation.Bridge.unregister_agent(self())
    end
  end
end

# Data pipeline workflow
defmodule JidoSystem.Workflows.DataPipelineFlow do
  use Jido.Workflow,
    name: "data_pipeline_flow",
    description: "ETL pipeline with real-time monitoring"

  def define_flow do
    [
      # Extract from multiple sources
      %{
        name: :extract_database,
        action: JidoSystem.Actions.ExtractFromDatabase,
        parallel_group: :extract,
        timeout: 30_000
      },
      %{
        name: :extract_api,
        action: JidoSystem.Actions.ExtractFromAPI,
        parallel_group: :extract,
        timeout: 60_000,
        retry: %{max_attempts: 3, backoff: :exponential}
      },
      %{
        name: :extract_files,
        action: JidoSystem.Actions.ExtractFromFiles,
        parallel_group: :extract,
        timeout: 120_000
      },
      
      # Transform data
      %{
        name: :merge_sources,
        action: JidoSystem.Actions.MergeDataSources,
        depends_on: [:extract_database, :extract_api, :extract_files],
        timeout: 60_000,
        resource_requirements: %{memory_mb: 1024}
      },
      %{
        name: :clean_data,
        action: JidoSystem.Actions.CleanData,
        depends_on: [:merge_sources],
        timeout: 30_000
      },
      %{
        name: :enrich_data,
        action: JidoSystem.Actions.EnrichData,
        depends_on: [:clean_data],
        timeout: 45_000,
        parallel_group: :transform
      },
      %{
        name: :validate_data,
        action: JidoSystem.Actions.ValidateData,
        depends_on: [:clean_data],
        timeout: 15_000,
        parallel_group: :transform
      },
      
      # Load to destinations
      %{
        name: :load_warehouse,
        action: JidoSystem.Actions.LoadToWarehouse,
        depends_on: [:enrich_data, :validate_data],
        timeout: 90_000,
        parallel_group: :load
      },
      %{
        name: :load_cache,
        action: JidoSystem.Actions.LoadToCache,
        depends_on: [:enrich_data, :validate_data],
        timeout: 30_000,
        parallel_group: :load
      },
      %{
        name: :generate_report,
        action: JidoSystem.Actions.GenerateReport,
        depends_on: [:load_warehouse],
        timeout: 60_000,
        on_error: :continue  # Non-critical
      }
    ]
  end
end

# Auto-scaling skill
defmodule JidoSystem.Skills.AutoScalingSkill do
  use Jido.Skill,
    name: "auto_scaling",
    description: "Automatically scales agents based on load",
    opts_key: :auto_scaling,
    signals: [
      input: ["system.load.*", "agent.queue.*", "performance.*"],
      output: ["scaling.agent.spawned", "scaling.agent.terminated"]
    ],
    config: [
      scale_up_threshold: [type: :float, default: 0.8],
      scale_down_threshold: [type: :float, default: 0.2],
      min_agents: [type: :integer, default: 1],
      max_agents: [type: :integer, default: 10],
      cooldown_period: [type: :integer, default: 60_000]
    ]

  def router do
    [
      %{
        path: "system.load.high",
        instruction: %{action: JidoSystem.Actions.ScaleUp},
        priority: 100,
        conditions: %{
          load_above: 0.8,
          agents_below_max: true
        }
      },
      %{
        path: "system.load.low", 
        instruction: %{action: JidoSystem.Actions.ScaleDown},
        priority: 50,
        conditions: %{
          load_below: 0.2,
          agents_above_min: true
        }
      },
      %{
        path: "agent.queue.overflow",
        instruction: %{action: JidoSystem.Actions.EmergencyScale},
        priority: 200
      }
    ]
  end
  
  # Custom skill logic for scaling decisions
  def handle_signal(%{type: "system.load.high", data: load_data}, state) do
    current_agents = length(state.managed_agents)
    
    if should_scale_up?(load_data, current_agents, state.config) do
      # Use Foundation's agent discovery to find suitable nodes
      {:ok, available_nodes} = Foundation.Coordination.get_available_nodes()
      
      target_node = select_best_node(available_nodes, load_data)
      
      # Spawn new agent using MABEAM coordination
      {:ok, new_agent} = spawn_agent_on_node(target_node, state.agent_template)
      
      # Register with Foundation
      :ok = JidoFoundation.Bridge.register_agent(new_agent,
        capabilities: [:task_processing, :auto_scaled],
        metadata: %{
          spawned_by: self(),
          spawn_reason: :high_load,
          target_node: target_node
        }
      )
      
      updated_state = %{state | managed_agents: [new_agent | state.managed_agents]}
      
      # Emit scaling event
      signal = Jido.Signal.new(%{
        source: "auto_scaling_skill",
        type: "scaling.agent.spawned",
        data: %{
          agent: new_agent,
          reason: :high_load,
          total_agents: length(updated_state.managed_agents)
        }
      })
      
      {:ok, updated_state, [signal]}
    else
      {:ok, state, []}
    end
  end
end

# Intelligent monitoring skill
defmodule JidoSystem.Skills.IntelligentMonitoringSkill do
  use Jido.Skill,
    name: "intelligent_monitoring",
    description: "AI-powered monitoring with predictive alerts",
    opts_key: :monitoring,
    signals: [
      input: ["*.metrics", "*.health.*", "*.performance.*"],
      output: ["alert.predictive.*", "insight.generated"]
    ],
    config: [
      prediction_window: [type: :integer, default: 300_000], # 5 minutes
      alert_confidence_threshold: [type: :float, default: 0.7],
      metric_history_limit: [type: :integer, default: 1000]
    ]

  def router do
    [
      %{
        path: "**.metrics",
        instruction: %{action: JidoSystem.Actions.AnalyzeMetrics},
        priority: 10
      },
      %{
        path: "system.health.**",
        instruction: %{action: JidoSystem.Actions.PredictIssues},
        priority: 50
      },
      %{
        path: "alert.predictive.**",
        instruction: %{action: JidoSystem.Actions.TriggerPreventiveAction},
        priority: 100
      }
    ]
  end
end

defmodule JidoSystem.Application do
  use Application
  require Logger

  def start(_type, _args) do
    Logger.info("Starting JidoSystem with Foundation integration")
    
    children = [
      # Foundation infrastructure first
      Foundation,
      
      # Jido task supervisor for async operations
      {Task.Supervisor, name: JidoSystem.TaskSupervisor},
      
      # Core agent supervisors
      {DynamicSupervisor, name: JidoSystem.AgentSupervisor, strategy: :one_for_one},
      
      # Start core system agents
      {JidoSystem.Agents.MonitorAgent, id: "system_monitor"},
      {JidoSystem.Agents.CoordinatorAgent, id: "main_coordinator"},
      
      # Start agent pool for task processing
      task_agent_pool(),
      
      # Signal router for inter-agent communication
      {JidoFoundation.SignalRouter, name: JidoSystem.SignalRouter},
      
      # Workflow scheduler
      {JidoSystem.WorkflowScheduler, []},
      
      # Health check endpoint for load balancers
      {JidoSystem.HealthCheck, port: 8080}
    ]
    
    opts = [strategy: :one_for_one, name: JidoSystem.Supervisor]
    
    case Supervisor.start_link(children, opts) do
      {:ok, pid} ->
        Logger.info("JidoSystem started successfully")
        register_system_with_discovery()
        {:ok, pid}
        
      {:error, reason} ->
        Logger.error("Failed to start JidoSystem: #{inspect(reason)}")
        {:error, reason}
    end
  end
  
  defp task_agent_pool do
    # Dynamic pool of task processing agents
    pool_size = Application.get_env(:jido_system, :task_agent_pool_size, 5)
    
    for i <- 1..pool_size do
      Supervisor.child_spec(
        {JidoSystem.Agents.TaskAgent, id: "task_agent_#{i}"},
        id: "task_agent_#{i}"
      )
    end
  end
  
  defp register_system_with_discovery do
    # Register the entire system with Foundation's discovery
    :ok = Foundation.register_service(:jido_system, %{
      version: Application.spec(:jido_system, :vsn),
      capabilities: [:task_processing, :workflow_execution, :monitoring],
      endpoints: [
        health: "http://localhost:8080/health",
        metrics: "http://localhost:8080/metrics"
      ],
      started_at: DateTime.utc_now()
    })
  end
end

# config/config.exs
import Config

# Foundation configuration
config :foundation,
  registry_impl: Foundation.Registry.ETS,
  coordination_impl: Foundation.Coordination.Local,
  infrastructure_impl: Foundation.Infrastructure.Local,
  telemetry_enabled: true,
  resource_limits: %{
    max_memory_mb: 2048,
    max_ets_entries: 1_000_000,
    max_registry_size: 100_000,
    cleanup_interval: 60_000,
    alert_threshold: 0.9
  }

# Jido system configuration
config :jido_system,
  task_agent_pool_size: 5,
  max_concurrent_workflows: 20,
  workflow_timeout: 300_000,
  auto_scaling_enabled: true,
  monitoring_enabled: true,
  signal_routing_enabled: true

# Jido framework configuration
config :jido,
  default_timeout: 60_000,
  task_supervisor: JidoSystem.TaskSupervisor,
  telemetry_enabled: true,
  error_strategy: :continue

# Environment-specific overrides
import_config "#{config_env()}.exs"

# config/prod.exs
import Config

config :jido_system,
  task_agent_pool_size: 20,
  max_concurrent_workflows: 100,
  auto_scaling_enabled: true,
  monitoring_enabled: true

config :foundation,
  resource_limits: %{
    max_memory_mb: 8192,
    max_ets_entries: 10_000_000,
    max_registry_size: 1_000_000,
    cleanup_interval: 30_000,
    alert_threshold: 0.8
  }

# Logger configuration for production
config :logger,
  level: :info,
  backends: [:console, {LoggerFileBackend, :file}]

config :logger, :file,
  path: "/var/log/jido_system/app.log",
  level: :info,
  format: "$date $time [$level] $metadata$message\n",
  metadata: [:agent_id, :workflow_id, :action]

# LLM-powered decision making agent
defmodule JidoSystem.AI.DecisionAgent do
  use JidoSystem.Agents.FoundationAgent,
    name: "decision_agent",
    description: "Makes intelligent decisions using LLM integration",
    actions: [
      JidoSystem.AI.Actions.AnalyzeContext,
      JidoSystem.AI.Actions.GenerateStrategy,
      JidoSystem.AI.Actions.MakeDecision
    ],
    capabilities: [:ai_decision_making, :context_analysis, :strategy_generation]

  @impl true
  def handle_instruction(%{action: JidoSystem.AI.Actions.MakeDecision} = instruction, agent) do
    # Use Foundation's circuit breaker for LLM calls
    result = JidoFoundation.Bridge.execute_protected(self(), fn ->
      call_llm_with_context(instruction.params.context, instruction.params.options)
    end,
      service_id: {:llm_service, :decision_making},
      timeout: 30_000,
      fallback: {:ok, %{decision: :fallback_strategy, confidence: 0.5}}
    )
    
    case result do
      {:ok, decision} ->
        # Update agent state with decision history
        updated_state = record_decision(agent.state, decision, instruction)
        
        # Emit decision telemetry
        JidoFoundation.Bridge.emit_agent_event(self(), :decision_made,
          %{confidence: decision.confidence},
          %{decision_type: instruction.params.decision_type}
        )
        
        {:ok, %{agent | state: updated_state}, decision}
        
      {:error, reason} ->
        {:error, %{reason: reason, fallback_available: true}}
    end
  end
end

# Context-aware workflow adapter
defmodule JidoSystem.AI.ContextualWorkflow do
  use Jido.Workflow,
    name: "contextual_workflow",
    description: "Adapts workflow execution based on context analysis"

  def run(workflow_spec, context) do
    # Analyze context using AI
    {:ok, analysis} = JidoSystem.AI.Actions.AnalyzeContext.run(
      %{context: context}, 
      %{agent_pid: self()}
    )
    
    # Adapt workflow based on analysis
    adapted_spec = adapt_workflow(workflow_spec, analysis)
    
    # Execute with Foundation monitoring
    execute_monitored_workflow(adapted_spec, context)
  end
  
  defp adapt_workflow(spec, analysis) do
    # AI-driven workflow adaptation logic
    spec
    |> adjust_timeouts_for_complexity(analysis.complexity)
    |> add_validation_steps_for_risk(analysis.risk_level)
    |> optimize_parallelization(analysis.parallelizability)
  end
end

# Cross-node agent coordination
defmodule JidoSystem.Distributed.ClusterCoordinator do
  use JidoSystem.Agents.FoundationAgent,
    name: "cluster_coordinator",
    description: "Coordinates agents across multiple nodes",
    capabilities: [:cluster_coordination, :node_management, :load_distribution]

  def distribute_task_across_cluster(task, requirements) do
    # Find capable agents across all nodes
    {:ok, all_agents} = Foundation.Coordination.find_agents_globally(
      requirements.capabilities,
      minimum_count: requirements.min_agents
    )
    
    # Group agents by node for optimal distribution
    agents_by_node = group_agents_by_node(all_agents)
    
    # Calculate optimal distribution strategy
    distribution_plan = calculate_distribution(task, agents_by_node, requirements)
    
    # Execute distributed task with coordination
    execute_distributed_task(distribution_plan)
  end
  
  defp execute_distributed_task(plan) do
    # Use MABEAM for cross-node coordination
    coordination_id = System.unique_integer()
    
    # Create coordination context
    {:ok, context} = JidoFoundation.Bridge.create_coordination_context(
      plan.agents,
      coordination_type: :distributed_task,
      timeout: plan.timeout
    )
    
    # Execute on each node with monitoring
    results = plan.nodes
    |> Task.async_stream(fn {node, agents, task_chunk} ->
      execute_on_node(node, agents, task_chunk, context)
    end, max_concurrency: length(plan.nodes))
    |> Enum.map(fn
      {:ok, result} -> result
      {:exit, reason} -> {:error, reason}
    end)
    
    # Aggregate results
    aggregate_distributed_results(results, plan)
  end
end

# Fault-tolerant agent migration
defmodule JidoSystem.Distributed.AgentMigration do
  @moduledoc """
  Handles agent migration between nodes for load balancing and fault tolerance.
  """
  
  def migrate_agent(agent_pid, target_node, options \\ []) do
    # Serialize agent state
    {:ok, state_snapshot} = capture_agent_state(agent_pid)
    
    # Create coordination for migration
    migration_id = "migration_#{System.unique_integer()}"
    
    # Use Foundation's coordination for safe migration
    Foundation.Coordination.coordinate_process_migration(
      agent_pid, 
      target_node,
      %{
        migration_id: migration_id,
        state_snapshot: state_snapshot,
        options: options
      }
    )
  end
  
  defp capture_agent_state(agent_pid) do
    # Safely capture agent state for migration
    state = Jido.Agent.get_state(agent_pid)
    pending_instructions = Jido.Agent.get_queue(agent_pid)
    
    {:ok, %{
      state: state,
      pending_instructions: pending_instructions,
      captured_at: DateTime.utc_now()
    }}
  end
end