igniter 0.5.0 → 0.5.1

data/{lib/igniter → packages/igniter-core/lib/igniter/core}/compiler/validators/dependencies_validator.rb

@@ -84,7 +84,13 @@ module Igniter
           raise @context.validation_error(node, "Branch '#{node.name}' must define at least one `on` case") if node.cases.empty?
           raise @context.validation_error(node, "Branch '#{node.name}' must define a `default` contract") unless node.default_contract
 
-          duplicate_matches = node.cases.group_by { |entry| entry[:match] }.select { |_match, entries| entries.size > 1 }.keys
+          validate_branch_case_matchers!(node)
+
+          duplicate_matches = node.cases
+            .flat_map { |entry| exact_branch_values(entry) }
+            .group_by(&:itself)
+            .select { |_match, entries| entries.size > 1 }
+            .keys
           return if duplicate_matches.empty?
 
           raise @context.validation_error(
@@ -93,6 +99,39 @@ module Igniter
           )
         end
 
+        def validate_branch_case_matchers!(node)
+          node.cases.each do |entry|
+            case entry[:matcher]
+            when :eq
+              next
+            when :in
+              unless entry[:value].is_a?(Array) && !entry[:value].empty?
+                raise @context.validation_error(node, "Branch '#{node.name}' `in:` cases must use a non-empty Array")
+              end
+            when :matches
+              unless entry[:value].is_a?(Regexp)
+                raise @context.validation_error(node, "Branch '#{node.name}' `matches:` cases must use a Regexp")
+              end
+            else
+              raise @context.validation_error(
+                node,
+                "Branch '#{node.name}' has unsupported matcher #{entry[:matcher].inspect}; use `eq:`, `in:`, or `matches:`"
+              )
+            end
+          end
+        end
+
+        def exact_branch_values(entry)
+          case entry[:matcher]
+          when :eq
+            [entry[:value]]
+          when :in
+            entry[:value]
+          else
+            []
+          end
+        end
+
         def validate_branch_contract!(node, contract_class)
           unless contract_class.is_a?(Class) && contract_class <= Igniter::Contract
             raise @context.validation_error(node, "Branch '#{node.name}' must reference Igniter::Contract subclasses")

data/{lib/igniter → packages/igniter-core/lib/igniter/core}/compiler.rb

@@ -9,6 +9,7 @@ require_relative "compiler/validators/dependencies_validator"
 require_relative "compiler/validators/callable_validator"
 require_relative "compiler/validators/type_compatibility_validator"
 require_relative "compiler/validators/await_validator"
+require_relative "compiler/validators/agent_validator"
 require_relative "compiler/validators/remote_validator"
 require_relative "compiler/validation_pipeline"
 require_relative "compiler/validator"

data/{lib/igniter → packages/igniter-core/lib/igniter/core}/contract.rb

@@ -19,8 +19,8 @@ module Igniter
         )
       end
 
-      def run_with(runner:, max_workers: nil)
-        @execution_options = { runner: runner, max_workers: max_workers }.compact
+      def run_with(runner:, max_workers: nil, **opts)
+        @execution_options = { runner: runner, max_workers: max_workers }.merge(opts).compact
       end
 
       # Ergonomic alias for run_with. Accepts pool_size: as a clearer name for
@@ -36,8 +36,33 @@ module Igniter
       end
 
       def restore_from_store(execution_id, store: nil)
-        snapshot = (store || Igniter.execution_store).fetch(execution_id)
-        restore(snapshot)
+        resolved_store = store || Igniter.execution_store
+        snapshot = resolved_store.fetch(execution_id)
+        restore(snapshot, store: resolved_store)
+      end
+
+      def agent_session_query_from_store(execution_id, store: nil)
+        restore_from_store(execution_id, store: store).execution.agent_session_query
+      end
+
+      def agent_session_summary_from_store(execution_id, store: nil)
+        agent_session_query_from_store(execution_id, store: store).summary
+      end
+
+      def orchestration_overview_from_store(execution_id, store: nil)
+        restore_from_store(execution_id, store: store).execution.orchestration_overview
+      end
+
+      def orchestration_summary_from_store(execution_id, store: nil)
+        orchestration_overview_from_store(execution_id, store: store)[:summary]
+      end
+
+      def orchestration_transition_overview_from_store(execution_id, store: nil, limit: 20)
+        restore_from_store(execution_id, store: store).execution.orchestration_transition_overview(limit: limit)
+      end
+
+      def orchestration_transition_summary_from_store(execution_id, store: nil)
+        restore_from_store(execution_id, store: store).execution.orchestration_transition_summary
       end
 
       def resume_from_store(execution_id, token:, value:, store: nil)
@@ -48,6 +73,30 @@ module Igniter
         )
       end
 
+      def resume_agent_session_from_store(execution_id, session:, node_name: nil, value: Runtime::Execution::UNDEFINED_RESUME_VALUE, store: nil)
+        Runtime::JobWorker.new(self, store: store || Igniter.execution_store).resume_agent_session(
+          execution_id: execution_id,
+          session: session,
+          node_name: node_name,
+          value: value
+        )
+      end
+
+      def continue_agent_session_from_store(execution_id, session:, payload:, trace: nil, token: nil, waiting_on: nil,
+                                            request: nil, reply: nil, phase: nil, store: nil)
+        Runtime::JobWorker.new(self, store: store || Igniter.execution_store).continue_agent_session(
+          execution_id: execution_id,
+          session: session,
+          payload: payload,
+          trace: trace,
+          token: token,
+          waiting_on: waiting_on,
+          request: request,
+          reply: reply,
+          phase: phase
+        )
+      end
+
       def define_schema(schema)
         @compiled_graph = DSL::SchemaBuilder.compile(schema, name: contract_name)
       end
@@ -91,11 +140,12 @@ module Igniter
         instance
       end
 
-      def restore(snapshot)
+      def restore(snapshot, store: nil)
         instance = new(
           snapshot[:inputs] || snapshot["inputs"] || {},
           runner: snapshot[:runner] || snapshot["runner"],
-          max_workers: snapshot[:max_workers] || snapshot["max_workers"]
+          max_workers: snapshot[:max_workers] || snapshot["max_workers"],
+          store: store
         )
         instance.restore_execution(snapshot)
       end
@@ -313,6 +363,26 @@ module Igniter
       execution.explain_plan(output_names)
     end
 
+    def orchestration_plan(output_names = nil)
+      execution.orchestration_plan(output_names)
+    end
+
+    def orchestration_overview(output_names = nil)
+      execution.orchestration_overview(output_names)
+    end
+
+    def orchestration_summary(output_names = nil)
+      execution.orchestration_summary(output_names)
+    end
+
+    def agent_session_query
+      execution.agent_session_query
+    end
+
+    def agent_session_summary
+      execution.agent_session_summary
+    end
+
     def success?
       execution.success?
     end

data/{lib/igniter → packages/igniter-core/lib/igniter/core}/dataflow.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "igniter/dataflow/diff"
-require "igniter/dataflow/diff_state"
-require "igniter/dataflow/window_filter"
-require "igniter/dataflow/incremental_collection_result"
-require "igniter/dataflow/aggregate_operators"
-require "igniter/dataflow/aggregate_state"
-require "igniter/model/aggregate_node"
+require_relative "dataflow/diff"
+require_relative "dataflow/diff_state"
+require_relative "dataflow/window_filter"
+require_relative "dataflow/incremental_collection_result"
+require_relative "dataflow/aggregate_operators"
+require_relative "dataflow/aggregate_state"
+require_relative "model/aggregate_node"
 
 module Igniter
   # Incremental Dataflow — Phase 1: differential collection processing.

data/packages/igniter-core/lib/igniter/core/diagnostics/agent_contributor.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module AgentContributor
+      class << self
+        def augment(report:, execution:)
+          agents = summarize_agents(execution)
+          return report if agents[:entries].empty?
+
+          report[:agents] = agents
+          augment_outputs(report: report, execution: execution, agents: agents)
+          augment_errors(report: report, agents: agents)
+          report
+        end
+
+        def append_text(report:, lines:)
+          agents = report[:agents]
+          return unless agents
+
+          summaries = agents[:entries].map do |entry|
+            summary = "#{entry[:node_name]}(#{entry[:status]} #{entry[:agent_trace_summary]})"
+            summary += " token=#{entry[:token]}" if entry[:token]
+            summary += " reply=#{entry[:reply_mode]}" if entry[:reply_mode]
+            summary += " phase=#{entry.dig(:agent_session, :phase)}" if entry.dig(:agent_session, :phase)
+            summary += " turn=#{entry.dig(:agent_session, :turn)}" if entry.dig(:agent_session, :turn)
+            summary
+          end
+
+          lines << "Agents: #{agents_overview(agents)} #{summaries.join(', ')}"
+        end
+
+        def append_markdown_summary(report:, lines:)
+          agents = report[:agents]
+          return unless agents
+
+          lines << "- Agents: #{agents_overview(agents)}"
+        end
+
+        def append_markdown_sections(report:, lines:)
+          agents = report[:agents]
+          return unless agents
+
+          lines << ""
+          lines << "## Agents"
+          agents[:entries].each do |entry|
+            line = "- `#{entry[:node_name]}` `#{entry[:status]}`: `#{entry[:agent_trace_summary]}`"
+            line += " token=`#{entry[:token]}`" if entry[:token]
+            line += " reply=`#{entry[:reply_mode]}`" if entry[:reply_mode]
+            line += " phase=`#{entry.dig(:agent_session, :phase)}`" if entry.dig(:agent_session, :phase)
+            line += " turn=`#{entry.dig(:agent_session, :turn)}`" if entry.dig(:agent_session, :turn)
+            line += " error=`#{entry[:error][:message]}`" if entry[:error]
+            lines << line
+          end
+        end
+
+        private
+
+        def summarize_agents(execution)
+          entries = execution.cache.values.filter_map { |state| agent_entry_for(state, execution) }
+
+          {
+            total: entries.size,
+            succeeded: entries.count { |entry| entry[:status] == :succeeded },
+            pending: entries.count { |entry| entry[:status] == :pending },
+            failed: entries.count { |entry| entry[:status] == :failed },
+            facets: summarize_agent_facets(entries),
+            entries: entries
+          }
+        end
+
+        def agent_entry_for(state, execution)
+          return unless state.node.kind == :agent
+
+          trace = extract_agent_trace(state)
+          return unless trace
+
+          events = summarize_node_events(execution, state.node.name)
+          entry = {
+            node_name: state.node.name,
+            path: state.node.path,
+            status: state.status,
+            reply_mode: state.node.reply_mode,
+            events: events,
+            agent_trace: trace,
+            agent_trace_summary: summarize_agent_trace(trace)
+          }
+
+          entry[:agent_session] = state.details[:agent_session] if state.details[:agent_session]
+
+          if state.pending? && state.value.is_a?(Igniter::Runtime::DeferredResult)
+            entry[:token] = state.value.token
+            entry[:waiting_on] = state.value.waiting_on
+            entry[:source_node] = state.value.source_node
+            entry[:agent_session] = state.value.agent_session_data if state.value.agent_session_data
+          end
+
+          if state.failed?
+            entry[:error] = {
+              type: state.error.class.name,
+              message: state.error.message
+            }
+          end
+
+          entry
+        end
+
+        def extract_agent_trace(state)
+          return state.details[:agent_trace] if state.details[:agent_trace]
+          return state.value.agent_trace if state.pending? && state.value.is_a?(Igniter::Runtime::DeferredResult) && state.value.agent_trace
+          return nil unless state.failed?
+
+          context = state.error.respond_to?(:context) ? state.error.context : {}
+          context[:agent_trace] || context["agent_trace"]
+        end
+
+        def augment_outputs(report:, execution:, agents:)
+          agent_by_node = agents[:entries].each_with_object({}) do |entry, memo|
+            memo[entry[:node_name].to_sym] = entry
+          end
+
+          execution.compiled_graph.outputs.each do |output_node|
+            entry = agent_by_node[output_node.source_root.to_sym]
+            value = report[:outputs][output_node.name]
+            next unless entry && value.is_a?(Hash)
+
+            report[:outputs][output_node.name] = value.merge(
+              agent_trace: entry[:agent_trace],
+              agent_trace_summary: entry[:agent_trace_summary],
+              agent_session: entry[:agent_session]
+            )
+          end
+        end
+
+        def augment_errors(report:, agents:)
+          agent_by_node = agents[:entries].each_with_object({}) do |entry, memo|
+            memo[entry[:node_name].to_sym] = entry
+          end
+
+          report[:errors].map! do |error|
+            entry = agent_by_node[error[:node_name].to_sym]
+            next error unless entry
+
+            error.merge(
+              agent_trace: entry[:agent_trace],
+              agent_trace_summary: entry[:agent_trace_summary]
+            )
+          end
+        end
+
+        def summarize_agent_facets(entries)
+          {
+            by_status: count_by(entries) { |entry| entry[:status] },
+            by_reply_mode: count_by(entries) { |entry| entry[:reply_mode] },
+            by_mode: count_by(entries) { |entry| hash_value(entry[:agent_trace], :mode) },
+            by_adapter: count_by(entries) { |entry| hash_value(entry[:agent_trace], :adapter) },
+            by_outcome: count_by(entries) { |entry| hash_value(entry[:agent_trace], :outcome) },
+            by_reason: count_by(entries) { |entry| hash_value(entry[:agent_trace], :reason) },
+            by_latest_event: count_by(entries) { |entry| entry.dig(:events, :latest_type) }
+          }
+        end
+
+        def summarize_node_events(execution, node_name)
+          events = execution.events.events.select { |event| event.node_name == node_name.to_sym }
+
+          {
+            total: events.size,
+            latest_type: events.last&.type,
+            types: events.map(&:type).uniq
+          }
+        end
+
+        def summarize_agent_trace(trace)
+          parts = []
+          adapter = hash_value(trace, :adapter)
+          mode = hash_value(trace, :mode)
+          via = hash_value(trace, :via)
+          message = hash_value(trace, :message)
+          local = hash_value(trace, :local)
+          registered = hash_value(trace, :registered)
+          alive = hash_value(trace, :alive)
+          outcome = hash_value(trace, :outcome)
+          reason = hash_value(trace, :reason)
+
+          parts << "adapter=#{adapter}" if adapter
+          parts << "mode=#{mode}" if mode
+          parts << "via=#{via}" if via
+          parts << "message=#{message}" if message
+          parts << "local=#{local}" unless local.nil?
+          parts << "registered=#{registered}" unless registered.nil?
+          parts << "alive=#{alive}" unless alive.nil?
+          parts << "outcome=#{outcome}" if outcome
+          parts << "reason=#{reason}" if reason
+          parts.join(" ")
+        end
+
+        def agents_overview(agents)
+          facets = agents[:facets] || {}
+          parts = [
+            "total=#{agents[:total]}",
+            "succeeded=#{agents[:succeeded]}",
+            "pending=#{agents[:pending]}",
+            "failed=#{agents[:failed]}"
+          ]
+          parts << "modes=#{inline_counts(facets[:by_mode])}" if present_counts?(facets[:by_mode])
+          parts << "replies=#{inline_counts(facets[:by_reply_mode])}" if present_counts?(facets[:by_reply_mode])
+          parts << "adapters=#{inline_counts(facets[:by_adapter])}" if present_counts?(facets[:by_adapter])
+          parts << "outcomes=#{inline_counts(facets[:by_outcome])}" if present_counts?(facets[:by_outcome])
+          parts << "reasons=#{inline_counts(facets[:by_reason])}" if present_counts?(facets[:by_reason])
+          parts.join(", ")
+        end
+
+        def count_by(entries)
+          entries.each_with_object(Hash.new(0)) do |entry, memo|
+            key = yield(entry)
+            next if key.nil?
+
+            memo[key.to_sym] += 1
+          end
+        end
+
+        def inline_counts(counts)
+          counts.map { |key, value| "#{key}=#{value}" }.join(", ")
+        end
+
+        def present_counts?(counts)
+          counts && !counts.empty?
+        end
+
+        def hash_value(hash, key)
+          return nil unless hash.is_a?(Hash)
+
+          return hash[key] if hash.key?(key)
+          return hash[key.to_s] if hash.key?(key.to_s)
+
+          nil
+        end
+      end
+    end
+  end
+end

data/packages/igniter-core/lib/igniter/core/diagnostics/capability_contributor.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../capabilities"
+
+module Igniter
+  module Diagnostics
+    module CapabilityContributor
+      class << self
+        def augment(report:, execution:)
+          entries = capability_entries(execution)
+          return report if entries.empty?
+
+          unique_capabilities = entries.flat_map { |entry| entry[:capabilities] }.uniq.sort
+          report[:capabilities] = {
+            total_nodes: entries.size,
+            pure_nodes: entries.count { |entry| entry[:pure] },
+            impure_nodes: entries.count { |entry| !entry[:pure] },
+            unique_capabilities: unique_capabilities,
+            by_capability: unique_capabilities.each_with_object({}) do |capability, memo|
+              memo[capability] = entries.count { |entry| entry[:capabilities].include?(capability) }
+            end,
+            nodes: entries,
+            policy: policy_summary(entries)
+          }
+          report
+        end
+
+        def append_text(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << "Capabilities: #{summary(capabilities)}"
+          lines << "Capability Policy: #{policy_text_summary(capabilities[:policy])}"
+        end
+
+        def append_markdown_summary(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << "- Capabilities: #{summary(capabilities)}"
+          lines << "- Capability Policy: #{policy_text_summary(capabilities[:policy])}"
+        end
+
+        def append_markdown_sections(report:, lines:)
+          capabilities = report[:capabilities]
+          return unless capabilities
+
+          lines << ""
+          lines << "## Capabilities"
+          lines << "- Summary: nodes=#{capabilities[:total_nodes]}, pure=#{capabilities[:pure_nodes]}, impure=#{capabilities[:impure_nodes]}, unique=#{list_or_none(capabilities[:unique_capabilities])}"
+          capabilities[:nodes].each do |entry|
+            lines << "- `#{entry[:node_name]}` executor=`#{entry[:executor_class] || "anonymous"}` capabilities=#{entry[:capabilities].join(", ")} pure=#{entry[:pure]}"
+          end
+          lines << ""
+          lines << "## Capability Policy"
+          lines << "- Summary: #{policy_text_summary(capabilities[:policy])}"
+          return unless capabilities[:policy][:configured]
+
+          capabilities[:policy][:nodes].each do |entry|
+            lines << "- `#{entry[:node_name]}` status=#{entry[:status]} allowed=#{list_or_none(entry[:allowed_capabilities])} denied=#{list_or_none(entry[:denied_capabilities])} risky=#{list_or_none(entry[:risky_capabilities])}"
+          end
+        end
+
+        private
+
+        def capability_entries(execution)
+          compiled_graph = execution.compiled_graph
+          nodes = compiled_graph.nodes + compiled_graph.outputs
+
+          nodes.each_with_object([]) do |node, memo|
+            executor_class = executor_for(node)
+            next unless executor_class
+
+            capabilities = Array(executor_class.declared_capabilities).map(&:to_sym).uniq.sort
+            next if capabilities.empty?
+
+            memo << {
+              node_name: node.name,
+              executor_class: executor_class.name,
+              capabilities: capabilities,
+              pure: executor_class.pure?
+            }
+          end
+        end
+
+        def executor_for(node)
+          callable = node.respond_to?(:callable) ? node.callable : nil
+          callable ||= node.respond_to?(:adapter_class) ? node.adapter_class : nil
+          return nil unless callable.is_a?(Class) && callable <= Igniter::Executor
+
+          callable
+        end
+
+        def policy_summary(entries)
+          policy = Igniter::Capabilities.policy
+          return { configured: false } unless policy
+
+          nodes = entries.map { |entry| classify_entry(entry, policy) }
+          {
+            configured: true,
+            denied_capabilities: Array(policy.denied).map(&:to_sym).sort,
+            on_unknown: policy.on_unknown.to_sym,
+            allowed_nodes: nodes.count { |entry| entry[:status] == :allowed },
+            denied_nodes: nodes.count { |entry| entry[:status] == :denied },
+            risky_nodes: nodes.count { |entry| entry[:status] == :risky },
+            nodes: nodes
+          }
+        end
+
+        def classify_entry(entry, policy)
+          denied_capabilities = entry[:capabilities] & Array(policy.denied).map(&:to_sym)
+          unknown_capabilities = entry[:capabilities] - Igniter::Capabilities::KNOWN
+          risky_capabilities = policy.on_unknown.to_sym == :warn ? unknown_capabilities : []
+          allowed_capabilities = entry[:capabilities] - denied_capabilities - risky_capabilities
+          status = if denied_capabilities.any?
+                     :denied
+                   elsif risky_capabilities.any?
+                     :risky
+                   else
+                     :allowed
+                   end
+
+          {
+            node_name: entry[:node_name],
+            status: status,
+            allowed_capabilities: allowed_capabilities.sort,
+            denied_capabilities: denied_capabilities.sort,
+            risky_capabilities: risky_capabilities.sort
+          }
+        end
+
+        def summary(capabilities)
+          [
+            "nodes=#{capabilities[:total_nodes]}",
+            "pure=#{capabilities[:pure_nodes]}",
+            "impure=#{capabilities[:impure_nodes]}",
+            "unique=#{list_or_none(capabilities[:unique_capabilities])}"
+          ].join(", ")
+        end
+
+        def policy_text_summary(policy)
+          return "configured=false" unless policy[:configured]
+
+          [
+            "configured=true",
+            "allowed=#{policy[:allowed_nodes]}",
+            "denied=#{policy[:denied_nodes]}",
+            "risky=#{policy[:risky_nodes]}",
+            "on_unknown=#{policy[:on_unknown]}"
+          ].join(", ")
+        end
+
+        def list_or_none(values)
+          array = Array(values)
+          return "none" if array.empty?
+
+          array.join("|")
+        end
+      end
+    end
+  end
+end

data/packages/igniter-core/lib/igniter/core/diagnostics/orchestration_contributor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Diagnostics
+    module OrchestrationContributor
+      class << self
+        def augment(report:, execution:)
+          orchestration = execution.orchestration_plan
+          return report unless orchestration && orchestration[:total].positive?
+
+          report[:orchestration] = orchestration
+          report
+        end
+
+        def append_text(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << "Orchestration: #{orchestration_overview(orchestration)}"
+          return if orchestration[:actions].empty?
+
+          lines << "Orchestration Actions: #{orchestration[:actions].map { |action| orchestration_action_text(action) }.join(', ')}"
+        end
+
+        def append_markdown_summary(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << "- Orchestration: #{orchestration_overview(orchestration)}"
+        end
+
+        def append_markdown_sections(report:, lines:)
+          orchestration = report[:orchestration]
+          return unless orchestration
+
+          lines << ""
+          lines << "## Orchestration"
+          lines << "- Summary: #{orchestration_overview(orchestration)}"
+          return if orchestration[:actions].empty?
+
+          lines << "- Actions: #{orchestration[:actions].map { |action| "`#{action[:action]}`(#{action[:node]})" }.join(', ')}"
+          orchestration[:actions].each do |action|
+            lines << "- `#{action[:node]}` `#{action[:action]}`: #{action[:guidance]} reason=`#{action[:reason]}`"
+          end
+        end
+
+        private
+
+        def orchestration_overview(orchestration)
+          parts = [
+            "total=#{orchestration[:total]}",
+            "attention_required=#{orchestration[:attention_required]}",
+            "resumable=#{orchestration[:resumable]}",
+            "interactive_sessions=#{orchestration[:interactive_sessions]}",
+            "manual_sessions=#{orchestration[:manual_sessions]}",
+            "single_turn_sessions=#{orchestration[:single_turn_sessions]}",
+            "deferred_calls=#{orchestration[:deferred_calls]}",
+            "actions=#{Array(orchestration[:actions]).size}"
+          ]
+          if Array(orchestration[:attention_nodes]).any?
+            parts << "attention_nodes=#{orchestration[:attention_nodes].join(',')}"
+          end
+          if orchestration[:by_action] && !orchestration[:by_action].empty?
+            parts << "by_action=#{orchestration[:by_action].map { |key, value| "#{key}=#{value}" }.join(',')}"
+          end
+          parts.join(", ")
+        end
+
+        def orchestration_action_text(action)
+          "#{action[:node]}(#{action[:action]} reason=#{action[:reason]})"
+        end
+      end
+    end
+  end
+end