Foundation.Perimeter.External.*
- DSPEx program creation requests
- Jido agent deployment commands  
- ML pipeline execution requests
- Multi-agent coordination requests
- Variable optimization requests

Foundation.Perimeter.Services.*
- MABEAM coordination interfaces
- Registry operations
- Infrastructure service boundaries
- Cross-service communication

Foundation.Perimeter.Coupling.*
- Direct Foundation → Jido function calls
- Shared data structure access
- Agent coordination without validation
- Signal routing optimization

Foundation.Core.*
- Protocol dispatch optimization
- Signal routing hot paths
- BEAM message optimization
- Foundation telemetry core

# Typical Foundation request flow
external_request                                    # 0ms
|> Foundation.Services.validate_everywhere()       # 14ms (current overhead)
|> Foundation.Registry.lookup()                    # 2ms  
|> Foundation.Coordination.coordinate()            # 8ms
|> Foundation.Core.execute()                       # 5ms
# Total: 29ms (48% validation overhead)

# Perimeter-optimized Foundation request flow
external_request                                    # 0ms
|> Foundation.Perimeter.External.validate()        # 5ms (Zone 1 only)
|> Foundation.Registry.lookup()                    # 2ms (Zone 2, cached)
|> Foundation.Coordination.coordinate()            # 8ms (Zone 3, no validation)
|> Foundation.Core.execute()                       # 5ms (Zone 4, no validation)
# Total: 20ms (25% validation overhead - 60% improvement)

# Before: Multiple validation layers
Foundation.Protocol.call(service, message)
|> validate_message()           # 2ms
|> validate_service_exists()    # 1ms  
|> validate_authorization()     # 1ms
|> Foundation.Core.dispatch()   # 0.1ms
# Total: 4.1ms (95% validation overhead)

# After: Single perimeter validation  
Foundation.Protocol.call(service, message)
|> Foundation.Perimeter.Services.validate()  # 1ms (Zone 2, cached)
|> Foundation.Core.dispatch()                # 0.1ms (Zone 4, trusted)
# Total: 1.1ms (90% validation overhead eliminated)

defmodule Foundation.Perimeter.External do
  external_contract :create_dspex_program do
    field :name, :string, required: true, length: 1..100
    field :schema_fields, {:list, :map}, required: true, validate: &validate_dspex_schema/1
    field :optimization_config, :map, validate: &validate_optimization_config/1
    field :foundation_context, :map, validate: &validate_foundation_context/1
    
    validate :ensure_foundation_compatibility
    validate :ensure_dspex_schema_validity  
  end
  
  # Foundation-specific validation
  defp ensure_foundation_compatibility(params) do
    case Foundation.Registry.can_support_dspex?(params.schema_fields) do
      true -> {:ok, params}
      false -> {:error, "DSPEx schema incompatible with Foundation services"}
    end
  end
end

external_contract :deploy_jido_agent do
  field :agent_spec, :map, required: true, validate: &validate_jido_spec/1
  field :foundation_integration, :map, required: true do
    field :registry_config, :map, validate: &validate_registry_config/1
    field :coordination_config, :map, validate: &validate_coordination_config/1
    field :telemetry_config, :map, validate: &validate_telemetry_config/1
  end
  field :clustering_config, :map, validate: &validate_clustering_config/1
  
  validate :ensure_foundation_agent_compatibility
  validate :ensure_clustering_viability
end

defmodule Foundation.Perimeter.Services do
  strategic_boundary :coordinate_agents do
    field :agent_group, {:list, :pid}, validate: &validate_agent_processes/1
    field :coordination_pattern, :atom, values: [:consensus, :pipeline, :map_reduce]
    field :foundation_context, :map do
      field :registry_scope, :atom, required: true
      field :telemetry_context, :map, required: true
    end
    
    validate :ensure_agents_in_foundation_registry
    validate :ensure_coordination_pattern_supported
  end
  
  strategic_boundary :foundation_registry_operation do
    field :operation_type, :atom, values: [:lookup, :register, :unregister, :update]
    field :service_id, :string, format: :uuid, required: true
    field :service_spec, :map, when: [:register, :update]
    
    validate :ensure_service_specification_valid
  end
end

defmodule Foundation.Perimeter.Coupling do
  @moduledoc """
  Zone 3: Productive coupling between Foundation and Jido.
  No validation overhead - trust Zone 2 perimeter guarantees.
  """
  
  # Direct function calls with shared data structures
  def coordinate_jido_agent_direct(agent_pid, foundation_context) do
    # No validation - Zone 2 guarantees valid inputs
    foundation_context
    |> Foundation.MABEAM.Core.create_coordination_context()
    |> Foundation.Registry.register_agent_context(agent_pid)
    |> Foundation.Coordination.coordinate_with_context()
  end
  
  # Shared data structure access
  def route_jido_signal_direct(signal, routing_context) do
    # Direct access to Foundation data structures
    Foundation.Core.route_signal_fast(signal, routing_context)
  end
  
  # Cross-system productive coupling
  def execute_jido_with_foundation_services(agent, execution_plan) do
    # Multiple Foundation services work together without validation
    agent
    |> Foundation.Registry.get_context!()
    |> Foundation.MABEAM.Core.coordinate_execution!()
    |> Foundation.Coordination.execute_with_telemetry!()
    |> Foundation.Core.finalize_execution!()
  end
end

defmodule Foundation.Core.PerimeterOptimized do
  @moduledoc """
  Zone 4: Core Foundation operations with zero validation overhead.
  """
  
  # Hot path signal routing (microsecond performance)
  def route_signals_fast(signals, routing_table) do
    # No validation - maximum Elixir performance
    signals
    |> Enum.group_by(&extract_route_key/1)
    |> Map.new(fn {route, signal_batch} ->
      {route, dispatch_batch_optimized(signal_batch, routing_table)}
    end)
  end
  
  # Foundation protocol dispatch optimization
  def protocol_dispatch_fast(protocol, message, context) do
    # Compile-time optimized dispatch
    case protocol do
      Foundation.Protocol.Registry -> Foundation.Registry.handle_fast(message, context)
      Foundation.Protocol.Coordination -> Foundation.Coordination.handle_fast(message, context)
      Foundation.Protocol.Telemetry -> Foundation.Telemetry.handle_fast(message, context)
    end
  end
  
  # Dynamic Foundation optimization
  def optimize_foundation_runtime(performance_metrics) do
    # Can use metaprogramming to optimize Foundation at runtime
    # Zone 1-2 perimeters ensure performance_metrics are valid
    performance_metrics
    |> analyze_bottlenecks()
    |> generate_optimized_code()
    |> hot_swap_foundation_modules()
  end
end