phronomy 0.5.4 → 0.6.0

data/lib/phronomy/event_loop.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Singleton event loop that manages all FSMSession instances.
+  #
+  # A single background thread reads from a global Thread::Queue and dispatches
+  # events to their target FSMSession. IO work (LLM calls, tool calls) runs in
+  # separate IO threads that post events back to the loop via EventLoop#post.
+  #
+  # Activated with: +Phronomy.configure { |c| c.event_loop = true }+
+  #
+  # == Fork safety
+  #
+  # +EventLoop.instance+ is lazily initialized. The background thread is not
+  # created until the first call, so Puma worker forking does not duplicate the
+  # thread. No +after_fork+ hook is required.
+  #
+  # == Deadlock warning
+  #
+  # Do NOT call +Workflow#invoke+ (in EventLoop mode) from within a workflow
+  # entry action. The entry action runs on the EventLoop thread; a nested
+  # +invoke+ would block waiting for the same thread to process events →
+  # deadlock. Use the async IO pattern instead (spawn a Thread, post events
+  # back to the EventLoop).
+  class EventLoop
+    # Returns the singleton instance, creating and starting it on first call.
+    def self.instance
+      @instance ||= new.tap(&:start)
+    end
+
+    # Stops and destroys the singleton. Primarily used in tests.
+    # @api private
+    def self.reset!
+      @instance&.stop
+      @instance = nil
+    end
+
+    def initialize
+      @queue = Thread::Queue.new  # global event queue (thread-safe; no Mutex needed)
+      @fsms = {}                 # { id => FSMSession }     — EventLoop thread only
+      @waiting = {}                 # { id => completion_queue } — EventLoop thread only
+    end
+
+    # Registers an FSMSession for execution and returns a completion queue.
+    #
+    # The session and its completion queue are handed off to the EventLoop thread
+    # via the queue payload, so +@fsms+ and +@waiting+ are exclusively written
+    # and read by the EventLoop thread. No Mutex is required.
+    #
+    # The caller blocks on +completion_queue.pop+ to receive the final context
+    # (WorkflowContext) once the workflow finishes or halts. If an error occurred,
+    # the popped value will be an Exception — callers are responsible for re-raising it.
+    #
+    # @param fsm_session [Phronomy::FSMSession]
+    # @return [Thread::Queue] resolves to final/halted context, or an Exception
+    def register(fsm_session)
+      if Thread.current[:phronomy_event_loop_thread]
+        raise Phronomy::Error,
+          "Cannot call Workflow#invoke (EventLoop mode) from within an EventLoop " \
+          "entry action. Use the async IO pattern: spawn a Thread, post events " \
+          "back via Phronomy::EventLoop.instance.post(...) instead."
+      end
+
+      completion_queue = Thread::Queue.new
+      # Pass both session and completion_queue in the event payload so that the
+      # EventLoop thread is the sole writer of @fsms and @waiting.
+      @queue.push(Event.new(type: :start, target_id: fsm_session.id,
+        payload: {session: fsm_session, completion: completion_queue}))
+      completion_queue
+    end
+
+    # Enqueues an {AgentFSM} as a fire-and-forget child session.
+    #
+    # Unlike {#register}, this method:
+    # - Is safe to call from the EventLoop thread (entry actions).
+    # - Does NOT block — no completion queue is created.
+    # - Delegates `:finished`/`:error` cleanup to the EventLoop via posted events.
+    #
+    # @param agent_fsm [Phronomy::Agent::FSM]
+    # @return [nil]
+    def enqueue_child(agent_fsm)
+      @queue.push(Event.new(type: :start, target_id: agent_fsm.id,
+        payload: {session: agent_fsm, completion: nil}))
+      nil
+    end
+
+    # Posts an event to the loop. Safe to call from any thread (including IO threads).
+    #
+    # @param event [Phronomy::Event]
+    def post(event)
+      @queue.push(event)
+    end
+
+    # Starts the background event loop thread.
+    # @return [self]
+    def start
+      @running = true
+      @thread = Thread.new do
+        Thread.current[:phronomy_event_loop_thread] = true
+        run_loop
+      end
+      @thread.abort_on_exception = false
+      self
+    end
+
+    # Stops the background thread. Used in tests only.
+    # @api private
+    def stop
+      @running = false
+      @thread&.kill
+      @thread = nil
+    end
+
+    private
+
+    def run_loop
+      while @running
+        event = @queue.pop
+
+        case event.type
+        when :finished, :halted, :error
+          # All three terminal events share the same cleanup path.
+          # Both @fsms and @waiting are exclusively owned by this thread.
+          @fsms.delete(event.target_id)
+          cq = @waiting.delete(event.target_id)
+          cq&.push(event.payload)
+
+        when :start
+          # session and completion_queue arrive together in the payload so that
+          # this thread is the sole writer of @fsms and @waiting.
+          # completion may be nil for fire-and-forget child sessions (AgentFSM).
+          @fsms[event.target_id] = event.payload[:session]
+          cq = event.payload[:completion]
+          @waiting[event.target_id] = cq if cq
+          event.payload[:session].start
+
+        else
+          @fsms[event.target_id]&.handle(event)
+        end
+      end
+    rescue => e
+      # Unblock all waiting callers if the loop dies unexpectedly.
+      @waiting.values.each { |cq| cq.push(e) }
+      raise
+    end
+  end
+end

data/lib/phronomy/fsm_session.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Event-driven execution wrapper for a single workflow run.
+  #
+  # Created by WorkflowRunner and registered with EventLoop. All public methods
+  # are called from the EventLoop thread — FSMSession is NOT thread-safe and must
+  # not be accessed concurrently from multiple threads.
+  #
+  # == Lifecycle
+  #
+  #   register(session) → EventLoop posts :start → session.start
+  #                                 ↓ (auto-transition present)
+  #                        EventLoop posts :state_completed → session.handle
+  #                                 ↓ (repeat)
+  #                        session posts :finished or :halted
+  #                                 ↓
+  #                        EventLoop pushes ctx to completion_queue → caller unblocks
+  #
+  # == Async IO pattern (EventLoop mode only)
+  #
+  # When a state has no auto-transition and is not a wait_state, but has an
+  # external event registered (e.g. +transition from: :fetching, on: :fetch_done+),
+  # the FSMSession stays registered in the EventLoop and waits for that event.
+  # The entry action is expected to spawn an IO thread that posts the event back:
+  #
+  #   entry :fetching, ->(ctx) {
+  #     Thread.new {
+  #       ctx.result = http.get(ctx.url)
+  #       Phronomy::EventLoop.instance.post(
+  #         Phronomy::Event.new(type: :fetch_done, target_id: ctx.thread_id, payload: nil)
+  #       )
+  #     }
+  #   }
+  #   transition from: :fetching, on: :fetch_done, to: :process
+  class FSMSession
+    FINISH = WorkflowRunner::FINISH
+
+    # @return [String] workflow thread_id (matches WorkflowContext#thread_id)
+    attr_reader :id
+
+    # @param id                  [String]
+    # @param context             [Object]        includes Phronomy::WorkflowContext
+    # @param entry_point         [Symbol]        initial state name
+    # @param entry_actions       [Hash]          { state_name => [callable, ...] }
+    # @param auto_state_set      [Hash]          { state_name => true }
+    # @param declared_states     [Array<Symbol>] all action state names
+    # @param wait_state_names    [Array<Symbol>]
+    # @param external_events     [Hash]          { event_name => [{from:, to:, guard:}] }
+    # @param phase_machine_class [Class]         state_machines-backed phase tracker class
+    # @param recursion_limit     [Integer]
+    # @param resume_event        [Symbol, nil]   external event to fire when resuming
+    # @param resume_phase        [Symbol, nil]   wait state name to resume from
+    def initialize(id:, context:, entry_point:, entry_actions:, auto_state_set:,
+      declared_states:, wait_state_names:, external_events:, phase_machine_class:,
+      recursion_limit:, resume_event: nil, resume_phase: nil)
+      @id = id
+      @ctx = context
+      @entry_point = entry_point
+      @entry_actions = entry_actions
+      @auto_state_set = auto_state_set
+      @declared_states = declared_states
+      @wait_state_names = wait_state_names
+      @external_events = external_events
+      @phase_machine_class = phase_machine_class
+      @recursion_limit = recursion_limit
+      @resume_event = resume_event
+      @resume_phase = resume_phase
+      @step = 0
+      @done = false
+      @current_state = nil
+      @tracker = nil
+    end
+
+    # Begins workflow execution. Called by EventLoop on :start event.
+    def start
+      if @resume_event
+        # Resume from wait state: position tracker at the wait state, then fire the
+        # external event. state_machines fires before_transition (exit) and
+        # after_transition (entry) callbacks, so both actions execute here.
+        @current_state = @resume_phase
+        @tracker = build_tracker(@current_state)
+        @tracker.context = @ctx
+        fire_and_advance!(@resume_event)
+      else
+        # Fresh start: state_machines does not fire callbacks on initialization,
+        # so we invoke the entry action for the initial state manually.
+        @current_state = @entry_point
+        @tracker = build_tracker(@current_state)
+        @tracker.context = @ctx
+        (@entry_actions[@current_state] || []).each { |c| c.call(@ctx) }
+        advance_or_halt
+      end
+    rescue => e
+      finish_with_error(e)
+    end
+
+    # Processes an event dispatched from EventLoop.
+    # Called for :state_completed and all user-defined external events.
+    #
+    # @param event [Phronomy::Event]
+    def handle(event)
+      return if @done
+
+      fire_and_advance!(event.type)
+    rescue => e
+      finish_with_error(e)
+    end
+
+    private
+
+    # Fires event_name on the phase tracker, updates @current_state, then
+    # calls advance_or_halt to decide what to do next.
+    def fire_and_advance!(event_name)
+      if @step >= @recursion_limit
+        raise Phronomy::RecursionLimitError,
+          "Recursion limit (#{@recursion_limit}) exceeded"
+      end
+
+      fire_event!(@tracker, event_name, @current_state)
+      next_phase = @tracker.phase.to_sym
+      # When next_phase == @current_state, no transition matched → treat as terminal.
+      @current_state = (next_phase == @current_state) ? FINISH : next_phase
+      @step += 1
+      advance_or_halt
+    end
+
+    # Determines the next action after the FSM has entered @current_state.
+    def advance_or_halt
+      return finish! if @current_state == FINISH
+
+      if @wait_state_names.include?(@current_state)
+        return halt!
+      end
+
+      if @auto_state_set.key?(@current_state)
+        event_loop.post(Event.new(type: :state_completed, target_id: @id, payload: nil))
+        return
+      end
+
+      if has_external_event_from?(@current_state)
+        # Async IO pattern: the entry action spawned an IO thread that will post
+        # an external event back. Stay registered; do nothing here.
+        return
+      end
+
+      # No transition declared — validate the state is known, then treat as terminal.
+      unless @declared_states.include?(@current_state)
+        raise ArgumentError, "State #{@current_state.inspect} is not defined"
+      end
+
+      finish!
+    end
+
+    def finish!
+      @done = true
+      @ctx.set_graph_metadata(thread_id: @id, phase: :__end__)
+      event_loop.post(Event.new(type: :finished, target_id: @id, payload: @ctx))
+    end
+
+    def halt!
+      @done = true
+      @ctx.set_graph_metadata(thread_id: @id, phase: @current_state)
+      event_loop.post(Event.new(type: :halted, target_id: @id, payload: @ctx))
+    end
+
+    def finish_with_error(err)
+      @done = true
+      event_loop.post(Event.new(type: :error, target_id: @id, payload: err))
+    end
+
+    def fire_event!(tracker, event_name, from_state)
+      return if tracker.send(event_name)
+
+      raise ArgumentError,
+        "Transition from #{from_state.inspect} via event #{event_name.inspect} failed. " \
+        "Ensure at least one guard matches or add a fallback (no-guard) transition."
+    end
+
+    def has_external_event_from?(state)
+      @external_events.any? { |_, transitions| transitions.any? { |t| t[:from] == state } }
+    end
+
+    def build_tracker(from_state)
+      machine = @phase_machine_class.new
+      machine.instance_variable_set(:@phase, from_state.to_s)
+      machine
+    end
+
+    def event_loop
+      Phronomy::EventLoop.instance
+    end
+  end
+end

data/lib/phronomy/generator_verifier.rb

@@ -133,7 +133,7 @@ module Phronomy
       @threshold = confidence_threshold.to_f
       @max_iterations = max_iterations.to_i
       @raise_if_untrusted = raise_if_untrusted
-      @compiled_graph = nil
+      @compiled_workflow = nil
     end
 
     # Run the generator-verifier pipeline.
@@ -144,7 +144,7 @@ module Phronomy
     # @raise [Phronomy::LowConfidenceError] when +raise_if_untrusted:+ is +true+
     #   and the result does not meet the confidence threshold
     def invoke(input, config: {})
-      app = compiled_graph
+      app = compiled_workflow
       state = app.invoke({input: input}, config: config)
       confidence = combined_confidence(state)
       trusted = confidence >= @threshold
@@ -166,8 +166,8 @@ module Phronomy
       [(state.self_score || 0.0).to_f, (state.review_score || 0.0).to_f].min
     end
 
-    def compiled_graph
-      @compiled_graph ||= build_workflow
+    def compiled_workflow
+      @compiled_workflow ||= build_workflow
     end
 
     def build_workflow
@@ -184,42 +184,42 @@ module Phronomy
       Phronomy::Workflow.define(PipelineState) do
         initial :draft
 
-        state :draft, action: ->(state) {
+        state :draft
+        state :review
+        state :finalize
+
+        entry :draft, ->(state) {
           feedback = state.review_notes.last
           prompt = dpb.call(state.input, feedback)
           result = draft_agent.invoke(prompt)
           parsed = drp.call(result[:output])
-          state.merge(
-            draft: parsed[:answer].to_s,
-            self_score: pipeline.__send__(:clamp, parsed[:confidence]),
-            citations: pipeline.__send__(:normalize_citations, parsed[:citations]),
-            iteration: state.iteration + 1
-          )
+          state.draft = parsed[:answer].to_s
+          state.self_score = pipeline.__send__(:clamp, parsed[:confidence])
+          state.citations = pipeline.__send__(:normalize_citations, parsed[:citations])
+          state.iteration = state.iteration + 1
         }
 
-        state :review, action: ->(state) {
+        entry :review, ->(state) {
           prompt = rpb.call(state.input, state.draft, state.citations)
           result = review_agent.invoke(prompt)
           parsed = rrp.call(result[:output])
-          state.merge(
-            review_score: pipeline.__send__(:clamp, parsed[:score]),
-            approved: parsed[:approved] == true,
-            review_notes: parsed[:feedback].to_s
-          )
+          state.review_score = pipeline.__send__(:clamp, parsed[:score])
+          state.approved = parsed[:approved] == true
+          state.review_notes << parsed[:feedback].to_s
         }
 
-        state :finalize, action: ->(state) { state.merge(output: state.draft) }
+        entry :finalize, ->(state) { state.output = state.draft }
 
-        after :draft, to: :review
-        after :finalize, to: :__finish__
+        transition from: :draft, to: :review
+        transition from: :finalize, to: :__finish__
 
-        event :route_review, from: :review,
+        transition from: :review,
           guard: ->(state) {
             confidence = [state.self_score || 0.0, state.review_score || 0.0].min
             (confidence >= threshold && state.approved) || state.iteration >= max_iter
           },
           to: :finalize
-        event :route_review, from: :review, to: :draft
+        transition from: :review, to: :draft
       end
     end
 

data/lib/phronomy/guardrail.rb

@@ -5,4 +5,3 @@
 require_relative "guardrail/base"
 require_relative "guardrail/input_guardrail"
 require_relative "guardrail/output_guardrail"
-require_relative "guardrail/builtin"

data/lib/phronomy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phronomy
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
 end

data/lib/phronomy/workflow.rb

@@ -8,18 +8,21 @@ module Phronomy
   #
   # Defines agent workflows in terms of *states* and *events* backed by
   # Phronomy::WorkflowRunner. This is the primary high-level API
-  # for graph-based execution in phronomy.
+  # for workflow-based execution in phronomy.
   #
   # == Basic usage
   #
   #   app = Phronomy::Workflow.define(MyContext) do
   #     initial :fetch
   #
-  #     state :fetch,   action: FETCH_NODE
-  #     state :process, action: PROCESS_NODE
+  #     state :fetch
+  #     state :process
   #
-  #     after :fetch,   to: :process
-  #     after :process, to: :__finish__
+  #     entry :fetch,   FETCH_NODE
+  #     entry :process, PROCESS_NODE
+  #
+  #     transition from: :fetch,   to: :process
+  #     transition from: :process, to: :__finish__
   #   end
   #
   #   result = app.invoke({ url: "https://example.com" })
@@ -29,15 +32,18 @@ module Phronomy
   #   app = Phronomy::Workflow.define(MyContext) do
   #     initial :propose
   #
-  #     state :propose, action: PROPOSE_NODE
+  #     state :propose
   #     wait_state :awaiting_approval
-  #     state :execute, action: EXECUTE_NODE
+  #     state :execute
+  #
+  #     entry :propose, PROPOSE_NODE
+  #     entry :execute, EXECUTE_NODE
   #
-  #     after :propose, to: :awaiting_approval
-  #     after :execute, to: :__finish__
+  #     transition from: :propose, to: :awaiting_approval
+  #     transition from: :execute, to: :__finish__
   #
-  #     event :approve, from: :awaiting_approval, to: :execute
-  #     event :reject,  from: :awaiting_approval, to: :propose
+  #     transition from: :awaiting_approval, on: :approve, to: :execute
+  #     transition from: :awaiting_approval, on: :reject,  to: :propose
   #   end
   #
   #   halted = app.invoke({ ... })
@@ -45,8 +51,8 @@ module Phronomy
   #
   # == Conditional transitions
   #
-  #   event :route, from: :decide, guard: ->(s) { s.score > 5 }, to: :high
-  #   event :route, from: :decide, to: :low   # fallback (no guard)
+  #   transition from: :decide, guard: ->(s) { s.score > 5 }, to: :high
+  #   transition from: :decide, to: :low   # fallback (no guard)
   #
   class Workflow
     include Phronomy::Runnable
@@ -91,7 +97,7 @@ module Phronomy
       @runner.send_event(state: state, event: event, input: input)
     end
 
-    # Streaming execution. Yields { node: Symbol, state: Object } after each node.
+    # Streaming execution. Yields { state: Symbol, context: Object } after each state action.
     # @param input [Hash]
     # @param config [Hash]
     # @yield [Hash]
@@ -112,12 +118,14 @@ module Phronomy
       def initialize(context_class)
         @context_class = context_class
         @initial = nil
-        # { node_name => callable }
-        @states = {}
-        # Array of { from:, to: } — auto-transitions after a state action
-        @after_transitions = []
-        # Array of { name:, from:, to:, guard: } — event-driven transitions
-        @event_transitions = []
+        # Ordered list of declared state names (action states only, not wait states).
+        @declared_states = []
+        # { state_name => [callable, ...] } — entry actions registered via entry()
+        @entry_actions = {}
+        # { state_name => [callable, ...] } — exit actions registered via exit()
+        @exit_actions = {}
+        # Array of { from:, to:, guard:, on: } — all transitions in declaration order
+        @transitions = []
         # Set of wait state names
         @wait_state_names = []
       end
@@ -131,83 +139,87 @@ module Phronomy
       # rubocop:enable Style/TrivialAccessors
 
       # Declares an action state.
-      # @param name [Symbol] state name
-      # @param action [#call, nil] callable invoked when entering the state.
-      #   If nil, the state is treated as a no-op pass-through.
+      # @param name   [Symbol]   state name
+      # @param action [#call, nil] optional entry action shorthand.
+      #   +state :generate, action: MY_PROC+ is equivalent to
+      #   +state :generate; entry :generate, MY_PROC+.
       def state(name, action: nil)
-        @states[name] = action || ->(s) { s }
+        @declared_states << name
+        entry(name, action) if action
+      end
+
+      # Declares an entry action for a state.
+      # The callable is invoked when the workflow enters +name+.
+      # It receives the current context and should mutate it in place.
+      # Return value is ignored.
+      # Multiple calls for the same state are allowed; callables fire in declaration order.
+      # @param name [Symbol] state name
+      # @param callable [#call] receives context, mutates it in place
+      def entry(name, callable)
+        (@entry_actions[name] ||= []) << callable
+      end
+
+      # Declares an exit action for a state.
+      # The callable is invoked when the workflow leaves +name+.
+      # It receives the current context and should mutate it in place.
+      # Return value is ignored.
+      # Multiple calls for the same state are allowed; callables fire in declaration order.
+      # @param name [Symbol] state name
+      # @param callable [#call] receives context, mutates it in place
+      def exit(name, callable)
+        (@exit_actions[name] ||= []) << callable
       end
 
       # Declares a wait state that automatically halts execution when reached.
-      # No action is registered; the workflow pauses here until an event resumes it.
+      # No entry action is registered; the workflow pauses here until an event resumes it.
       # @param name [Symbol] wait state name (conventionally :awaiting_something)
       def wait_state(name)
         @wait_state_names << name
       end
 
-      # Declares an automatic transition that fires after a state's action completes.
-      # @param from [Symbol] source state name
-      # @param to [Symbol] destination state name or :__finish__
-      def after(from, to:)
-        dest = (to == :__finish__) ? FINISH : to
-        @after_transitions << {from: from, to: dest}
-      end
-
-      # Declares an event-driven transition.
-      # When +guard:+ is provided, the transition is taken only if the guard
-      # returns truthy for the current context. Multiple events with the same
-      # name and source are evaluated in declaration order; the first passing
-      # guard wins.
-      # @param name [Symbol] event name
-      # @param from [Symbol] source state where this event can be fired
+      # Declares a transition between states.
+      # Auto-fire transitions (no +on:+) fire automatically when an action state's
+      # action completes. External transitions (+on: :event_name+) are triggered
+      # manually via +send_event+.
+      # When +guard:+ is provided the transition is taken only if the guard returns
+      # truthy for the current context. Multiple transitions from the same source are
+      # evaluated in declaration order; the first passing guard wins.
+      # @param from [Symbol] source state
       # @param to [Symbol] destination state or :__finish__
       # @param guard [Proc, nil] optional guard — receives context, returns truthy/falsy
-      def event(name, from:, to:, guard: nil)
+      # @param on [Symbol, nil] named event for manual triggers (e.g. :approve)
+      def transition(from:, to:, guard: nil, on: nil)
         dest = (to == :__finish__) ? FINISH : to
-        @event_transitions << {name: name, from: from, to: dest, guard: guard}
+        @transitions << {from: from, to: dest, guard: guard, on: on}
       end
 
       # Builds and returns a Phronomy::Workflow backed by a WorkflowRunner.
       def build
-        nodes = @states.dup
-
-        # After-transitions: { from => to }
-        # Unconditional transitions that fire automatically after an action state completes.
-        after_transitions = @after_transitions.each_with_object({}) do |t, h|
-          h[t[:from]] = t[:to]
-        end
-
-        # Route transitions: { from => {event_name:, entries: [{guard:, to:}, ...]} }
-        # Events declared from action states (not wait states) fire automatically
-        # after the action completes. The event name is used to register the
-        # state_machines event and may be any symbol (e.g. :route, :route_review).
-        # Declaration order is preserved so guarded entries appear before fallbacks.
-        route_transitions = {}
+        entry_actions = @entry_actions.dup
+        exit_actions = @exit_actions.dup
 
-        # External events: { event_name => [{from:, to:, guard:}, ...] }
-        # Events declared from wait states, triggered by human input (e.g. :approve).
+        # Auto-fire transitions (no :on): fire automatically when action completes.
+        # External events (with :on): triggered manually via send_event.
+        auto_transitions = []
         external_events = {}
 
-        @event_transitions.each do |t|
-          if @wait_state_names.include?(t[:from])
-            # Source is a wait state → external event
-            external_events[t[:name]] ||= []
-            external_events[t[:name]] << {from: t[:from], to: t[:to], guard: t[:guard]}
+        @transitions.each do |t|
+          if t[:on]
+            external_events[t[:on]] ||= []
+            external_events[t[:on]] << {from: t[:from], to: t[:to], guard: t[:guard]}
           else
-            # Source is an action state → routing event (auto-fires after action)
-            # The event name is taken from the first declaration for each from-state.
-            route_transitions[t[:from]] ||= {event_name: t[:name], entries: []}
-            route_transitions[t[:from]][:entries] << {guard: t[:guard], to: t[:to]}
+            auto_transitions << {from: t[:from], to: t[:to], guard: t[:guard]}
           end
         end
 
         runner = Phronomy::WorkflowRunner.new(
           state_class: @context_class,
-          nodes: nodes,
-          after_transitions: after_transitions,
-          route_transitions: route_transitions,
+          entry_actions: entry_actions,
+          exit_actions: exit_actions,
+          declared_states: @declared_states.dup,
+          auto_transitions: auto_transitions,
           external_events: external_events,
-          entry_point: @initial || nodes.keys.first,
+          entry_point: @initial || @declared_states.first,
           wait_state_names: @wait_state_names
         )