DSPEx.Application
├── Jido.Application                    # Primary foundation
├── DSPEx.Foundation.Bridge             # MABEAM integration layer
├── DSPEx.Variables.Supervisor          # Cognitive Variables as Jido agents
├── DSPEx.Signature.Supervisor          # Native DSPy syntax support
└── DSPEx.Infrastructure.Supervisor     # Minimal services

mkdir -p lib/dsp_ex/{foundation,variables,signature,coordination,clustering}
mkdir -p lib/dsp_ex/variables/{actions,sensors,skills}
mkdir -p lib/dsp_ex/signature/{dsl,compiler,types}
mkdir -p test/dsp_ex/{foundation,variables,signature}

{:jido, "~> 0.1"},
{:uuid, "~> 1.1"},
{:jason, "~> 1.4"},
{:telemetry, "~> 1.2"}

defmodule DSPEx.Application do
  use Application
  
  def start(_type, _args) do
    children = [
      # Primary Jido foundation
      {Jido.Application, []},
      
      # DSPEx components
      DSPEx.Foundation.Bridge,
      DSPEx.Variables.Supervisor,
      DSPEx.Signature.Supervisor,
      DSPEx.Infrastructure.Supervisor
    ]
    
    Supervisor.start_link(children, strategy: :one_for_one, name: DSPEx.Supervisor)
  end
end

defmodule DSPEx.Foundation.Bridge do
  @moduledoc """
  Bridge between Jido agents and Foundation MABEAM coordination patterns.
  Provides selective integration of advanced coordination without coupling.
  """
  
  use GenServer
  
  # Simple registry integration
  def register_cognitive_variable(id, metadata) do
    GenServer.call(__MODULE__, {:register_variable, id, metadata})
  end
  
  # Basic agent discovery
  def find_affected_agents(agent_specs) do
    GenServer.call(__MODULE__, {:find_agents, agent_specs})
  end
  
  # Minimal consensus for critical coordination
  def start_consensus(participants, proposal, timeout) do
    GenServer.call(__MODULE__, {:start_consensus, participants, proposal, timeout})
  end
end

defmodule DSPEx.Variables.CognitiveFloat do
  @moduledoc """
  Revolutionary cognitive variable that is both a Jido agent AND uses MABEAM coordination
  """
  
  use Jido.Agent
  
  @actions [
    DSPEx.Variables.Actions.UpdateValue,
    DSPEx.Variables.Actions.CoordinateAffectedAgents,
    DSPEx.Variables.Actions.AdaptBasedOnFeedback
  ]
  
  @sensors [
    DSPEx.Variables.Sensors.PerformanceFeedbackSensor,
    DSPEx.Variables.Sensors.AgentHealthMonitor
  ]
  
  defstruct [
    :name,
    :current_value,
    :valid_range,
    :affected_agents,
    :adaptation_strategy,
    coordination_enabled: true,
    performance_history: []
  ]
  
  def mount(agent, opts) do
    initial_state = struct(__MODULE__, opts)
    
    # Register with Foundation Bridge for coordination
    DSPEx.Foundation.Bridge.register_cognitive_variable(agent.id, initial_state)
    
    {:ok, initial_state}
  end
end

defmodule DSPEx.Signature.DSL do
  @moduledoc """
  Native DSPy signature syntax support for ElixirML
  """
  
  defmacro __using__(_opts) do
    quote do
      import DSPEx.Signature.DSL
      Module.register_attribute(__MODULE__, :signatures, accumulate: true)
    end
  end
  
  defmacro signature(definition) do
    quote do
      @signatures unquote(definition)
      
      def __signature__() do
        @signatures |> List.first() |> DSPEx.Signature.Compiler.compile()
      end
    end
  end
end

defmodule BasicQA do
  use DSPEx.Signature.DSL
  
  signature "question: str, context?: str -> answer: str, confidence: float"
end

defmodule QAAgent do
  use Jido.Agent
  
  @actions [QAAgent.Actions.ProcessQuestion]
  
  def mount(agent, opts) do
    initial_state = %{
      temperature: 0.7,
      model: :mock_llm
    }
    {:ok, initial_state}
  end
end

defmodule QASystem do
  def process(question, opts \\ []) do
    context = Keyword.get(opts, :context, "")
    
    # Get temperature from cognitive variable
    {:ok, temp} = DSPEx.Variables.get_value(:temperature)
    
    # Process with QA agent
    {:ok, agent} = Jido.get_agent("qa_processor")
    {:ok, result} = Jido.Agent.cmd(agent, QAAgent.Actions.ProcessQuestion, %{
      question: question,
      context: context,
      temperature: temp
    })
    
    result
  end
end

defmodule CodeGenTeam do
  use DSPEx.MABEAM.CognitiveTeam
  
  agent :coder, CoderAgent, %{language: :elixir}
  agent :reviewer, ReviewerAgent, %{strictness: 0.8}
  
  cognitive_variable :review_strategy, :choice,
    choices: [:fast, :thorough, :adaptive],
    default: :adaptive
end

test "complete QA pipeline with variable coordination" do
  # Initialize system
  {:ok, _} = QASystem.start_link()
  
  # Test signature compilation
  assert BasicQA.__signature__() != nil
  
  # Test variable coordination
  assert :ok = DSPEx.Variables.set(:temperature, 0.8)
  
  # Test pipeline processing
  result = QASystem.process("What is Elixir?", context: "Elixir is a programming language")
  
  assert result.answer != nil
  assert result.confidence > 0.0
  assert result.temperature == 0.8  # Variable coordination worked
  
  # Test supervision 
  agent_pid = QASystem.get_agent_pid()
  Process.exit(agent_pid, :kill)
  :timer.sleep(100)  # Allow supervisor to restart
  
  # Should still work after restart
  result2 = QASystem.process("What is AI?")
  assert result2.answer != nil
end