phronomy 0.2.2 → 0.3.0

data/lib/phronomy/agent/checkpoint.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    # Encapsulates the suspended state of an agent invocation.
+    #
+    # A Checkpoint is returned as the +:checkpoint+ key of the result hash when
+    # an approval-required tool is encountered and no synchronous
+    # on_approval_required handler has been registered.
+    #
+    # Pass the checkpoint to Agent::Base#resume to continue execution after
+    # obtaining an approval decision from the user or an external system.
+    #
+    # @example Suspend and resume
+    #   result = agent.invoke("Do task X")
+    #   if result[:suspended]
+    #     approved = prompt_user(result[:checkpoint].pending_tool_name)
+    #     result   = agent.resume(result[:checkpoint], approved: approved)
+    #   end
+    #   puts result[:output]
+    class Checkpoint
+      # @return [String, nil] the thread_id from the invocation config
+      attr_reader :thread_id
+
+      # @return [Array<RubyLLM::Message>] conversation messages up to and including
+      #   the assistant message that requested the pending tool call
+      attr_reader :messages
+
+      # @return [String] the name of the tool awaiting approval
+      attr_reader :pending_tool_name
+
+      # @return [Hash] the arguments the LLM passed to the pending tool
+      attr_reader :pending_tool_args
+
+      # @return [String] the tool_call_id from the LLM response (required to
+      #   inject the tool result message on resume)
+      attr_reader :pending_tool_call_id
+
+      # @param thread_id           [String, nil]
+      # @param messages            [Array<RubyLLM::Message>]
+      # @param pending_tool_name   [String]
+      # @param pending_tool_args   [Hash]
+      # @param pending_tool_call_id [String]
+      def initialize(thread_id:, messages:, pending_tool_name:, pending_tool_args:, pending_tool_call_id:)
+        @thread_id = thread_id
+        @messages = messages.dup.freeze
+        @pending_tool_name = pending_tool_name
+        @pending_tool_args = pending_tool_args
+        @pending_tool_call_id = pending_tool_call_id
+      end
+    end
+  end
+end

data/lib/phronomy/agent/react_agent.rb

@@ -18,18 +18,11 @@ module Phronomy
           # Run input guardrails before any LLM interaction.
           run_input_guardrails!(input)
 
-          memory = config[:memory]
-          thread_id = config[:thread_id]
+          config[:thread_id]
           max_iter = self.class.max_iterations
 
-          # Seed with persisted messages when memory is provided.
-          initial_messages = if memory && thread_id
-            load_from_memory(memory, thread_id: thread_id, query: extract_message(input))
-          else
-            []
-          end
-
-          messages = initial_messages.dup
+          # Seed with app-managed conversation history when provided.
+          messages = Array(config[:messages]).dup
           user_asked = false
           total_usage = Phronomy::TokenUsage.zero
           iterations_exhausted = true
@@ -45,12 +38,8 @@ module Phronomy
             end
           end
 
-          save_to_memory(memory, thread_id: thread_id, messages: messages) if memory && thread_id
-
-          # Fall back to the last message that carries non-nil content. This
+          # Fall back to the last message
           # guards against the case where the final message is a tool-call or
-          # tool-result message (content == nil) when max_iterations is
-          # exhausted before the model produces a text reply.
           output = messages.reverse.find { |m| m.content && !m.content.empty? }&.content
 
           # Run output guardrails before returning to the caller.
@@ -80,17 +69,10 @@ module Phronomy
         trace("agent.invoke", input: input, **caller_meta) do |_span|
           run_input_guardrails!(input)
 
-          memory = config[:memory]
-          thread_id = config[:thread_id]
+          config[:thread_id]
           max_iter = self.class.max_iterations
 
-          initial_messages = if memory && thread_id
-            load_from_memory(memory, thread_id: thread_id, query: extract_message(input))
-          else
-            []
-          end
-
-          messages = initial_messages.dup
+          messages = Array(config[:messages]).dup
           user_asked = false
           total_usage = Phronomy::TokenUsage.zero
           iterations_exhausted = true
@@ -106,8 +88,6 @@ module Phronomy
             end
           end
 
-          save_to_memory(memory, thread_id: thread_id, messages: messages) if memory && thread_id
-
           # Fall back to the last message that carries non-nil content (same as
           # the non-streaming path above).
           output = messages.reverse.find { |m| m.content && !m.content.empty? }&.content
@@ -154,8 +134,18 @@ module Phronomy
         chat = build_chat
         messages.each { |m| chat.add_message(m) }
 
-        chat.before_tool_call { |tc| block.call(StreamEvent.new(type: :tool_call, payload: {tool_call: tc})) }
-        chat.after_tool_result { |tr| block.call(StreamEvent.new(type: :tool_result, payload: {tool_result: tr})) }
+        current_tool_call = nil
+        chat.on_tool_call do |tc|
+          current_tool_call = tc
+          block.call(StreamEvent.new(type: :tool_call, payload: {tool_call: tc}))
+        end
+        chat.on_tool_result do |tr|
+          block.call(StreamEvent.new(type: :tool_result, payload: {
+            tool_call_id: current_tool_call&.id,
+            tool_name: current_tool_call&.name,
+            tool_result: tr
+          }))
+        end
 
         # Run before_completion hooks before each LLM call in the streaming loop.
         run_before_completion_hooks!(chat, config)

data/lib/phronomy/agent/suspend_signal.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Phronomy
+  module Agent
+    # Raised internally inside the on_tool_call hook when an approval-required
+    # tool is encountered and no synchronous on_approval_required handler has
+    # been registered.  Caught by Agent::Base#invoke_once to produce a
+    # suspended result hash containing a Checkpoint.
+    #
+    # This class is intentionally NOT part of the public API.  Callers should
+    # inspect the +:suspended+ key in the result hash returned by #invoke.
+    #
+    # @api private
+    class SuspendSignal < StandardError
+      # @return [String] the name of the tool that triggered the suspension
+      attr_reader :tool_name
+
+      # @return [Hash] the arguments the LLM passed to the tool
+      attr_reader :args
+
+      # @return [String] the tool_call_id from the LLM response
+      attr_reader :tool_call_id
+
+      # @param tool_name    [String]
+      # @param args         [Hash]
+      # @param tool_call_id [String]
+      def initialize(tool_name:, args:, tool_call_id:)
+        super("Agent suspended waiting for approval of tool: #{tool_name}")
+        @tool_name = tool_name
+        @args = args
+        @tool_call_id = tool_call_id
+      end
+    end
+  end
+end

data/lib/phronomy/agent.rb

@@ -7,7 +7,8 @@ module Phronomy
     # type values:
     #   :token       — a content delta from the LLM (payload: { content: String })
     #   :tool_call   — the LLM requested a tool call (payload: { tool_call: Object })
-    #   :tool_result — a tool finished executing (payload: { tool_result: Object })
+    #   :tool_result — a tool finished executing (payload: { tool_call_id: String, tool_name: String,
+    #                                                         tool_result: Object })
     #   :done        — the agent finished (payload: { output: String, messages: Array,
     #                                                  usage: TokenUsage })
     #   :error       — an unrecoverable error occurred (payload: { error: Exception })

data/lib/phronomy/configuration.rb

@@ -16,20 +16,6 @@ module Phronomy
     # Default embedding model name
     attr_accessor :default_embedding_model
 
-    # Default StateStore instance (nil = no persistence)
-    attr_accessor :default_state_store
-
-    # Default Memory instance
-    attr_accessor :default_memory
-
-    # When true, all memory backends write asynchronously via ActiveJob by default.
-    # Individual instances can still override with their own async: option.
-    # Requires ActiveJob to be available.
-    attr_accessor :memory_async
-
-    # ActiveJob queue name used for async memory writes (default: :default)
-    attr_accessor :memory_job_queue
-
     # Tracer instance
     attr_accessor :tracer
 
@@ -47,20 +33,10 @@ module Phronomy
     # the tracing backend (OTel, Langfuse, etc.).
     attr_accessor :trace_pii
 
-    # Maximum number of Actors that {ThreadActorRegistry} may hold simultaneously.
-    # When the registry is full, the least-recently-used Actor is stopped and
-    # evicted before a new one is created.
-    # Defaults to +nil+ (no limit).  Set to a positive integer for long-running
-    # server processes that handle many distinct conversation threads.
-    attr_accessor :max_actors
-
     def initialize
       @recursion_limit = 25
       @tracer = Phronomy::Tracing::NullTracer.new
-      @memory_async = false
-      @memory_job_queue = :default
       @trace_pii = true
-      @max_actors = nil
     end
   end
 end

data/lib/phronomy/guardrail/builtin/pii_pattern_detector.rb

@@ -7,10 +7,10 @@ module Phronomy
       #
       # Four categories are supported and each can be individually toggled:
       #
-      # - +:my_number+   — Japanese My Number (12-digit national ID)
+      # - +:ssn+         — US Social Security Numbers (###-##-####)
       # - +:credit_card+ — Credit / debit card numbers
       # - +:email+       — E-mail addresses
-      # - +:phone+       — Japanese domestic phone numbers
+      # - +:phone+       — Phone numbers
       #
       # All four categories are active by default.
       #
@@ -24,13 +24,10 @@ module Phronomy
       class PIIPatternDetector < InputGuardrail
         # Recognised PII categories and their detection patterns.
         PATTERNS = {
-          # Japanese My Number: 12 consecutive or grouped digits (4-4-4).
-          # Matched candidates are additionally validated with the official check-digit
-          # algorithm (JIS X 0076) to eliminate false positives from arbitrary 12-digit strings.
-          my_number: {
-            pattern: /(?<!\d)(?<!\d[- ])\d{4}[- ]?\d{4}[- ]?\d{4}(?![- ]?\d)/,
-            label: "My Number",
-            validate_my_number: true
+          # US Social Security Number: ###-##-#### (hyphens required).
+          ssn: {
+            pattern: /\b\d{3}-\d{2}-\d{4}\b/,
+            label: "SSN"
           },
           # Credit / debit card: 16 digits, optionally separated by spaces or hyphens.
           # Matched candidates are additionally validated with the Luhn algorithm
@@ -45,9 +42,10 @@ module Phronomy
             pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
             label: "email address"
           },
-          # Japanese phone number: starts with 0, groups of 2-5 / 1-4 / 4 digits.
+          # Phone number: 3-digit area code, 3-4-digit exchange, 4-digit subscriber;
+          # optional E.164 country-code prefix (e.g. +1, +44).
           phone: {
-            pattern: /\b0\d{1,4}[- ]?\d{1,4}[- ]?\d{4}\b/,
+            pattern: /(?:\+\d{1,3}[.\- ]?)?\(?\d{3}\)?[.\- ]?\d{3,4}[.\- ]?\d{4}\b/,
             label: "phone number"
           }
         }.freeze
@@ -55,7 +53,7 @@ module Phronomy
         ALL_CATEGORIES = PATTERNS.keys.freeze
 
         # @param detect [Array<Symbol>] categories to detect.
-        #   Defaults to all four: +:my_number+, +:credit_card+, +:email+, +:phone+.
+        #   Defaults to all four: +:ssn+, +:credit_card+, +:email+, +:phone+.
         # @raise [ArgumentError] when an unknown category symbol is provided.
         def initialize(detect: ALL_CATEGORIES)
           unknown = Array(detect) - ALL_CATEGORIES
@@ -74,10 +72,6 @@ module Phronomy
               # Scan for all candidates then filter by Luhn check-digit validation.
               # This avoids false positives on arbitrary 16-digit strings (e.g. internal IDs).
               text.scan(entry[:pattern]).any? { |m| luhn_valid?(m.gsub(/[- ]/, "")) }
-            elsif entry[:validate_my_number]
-              # Scan for all candidates then apply the JIS X 0076 check-digit algorithm.
-              # This avoids false positives on arbitrary 12-digit strings.
-              text.scan(entry[:pattern]).any? { |m| my_number_valid?(m.gsub(/[- ]/, "")) }
             else
               text.match?(entry[:pattern])
             end
@@ -87,17 +81,6 @@ module Phronomy
 
         private
 
-        # Returns true when +digits+ (a 12-character string of decimal digits) satisfies
-        # the Japanese My Number check-digit algorithm defined in JIS X 0076.
-        # The check digit is the 12th digit.
-        def my_number_valid?(digits)
-          weights = [6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
-          total = weights.each_with_index.sum { |w, i| w * digits[i].to_i }
-          remainder = total % 11
-          check = (remainder <= 1) ? 0 : 11 - remainder
-          check == digits[11].to_i
-        end
-
         # Returns true when +digits+ (a string of decimal digits) satisfies the
         # Luhn check-digit algorithm used by payment card networks.
         def luhn_valid?(digits)

data/lib/phronomy/railtie.rb

@@ -30,16 +30,10 @@ module Phronomy
 
     # Loads Phronomy::Rails::AgentJob when both ActionCable and ActiveJob are present.
     initializer "phronomy.agent_job" do
-      if defined?(::ActionCable) && defined?(::ActiveJob)
-        require "phronomy/rails/agent_job"
-      end
     end
 
     # Loads Phronomy ActiveRecord extensions when ActiveRecord is available.
     initializer "phronomy.active_record", after: "active_record.initialize_database" do
-      ActiveSupport.on_load(:active_record) do
-        require "phronomy/active_record/extensions" if defined?(::ActiveRecord)
-      end
     end
   end
 end

data/lib/phronomy/ruby_llm_patches.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Patches for upstream ruby_llm bugs that have not yet been released.
+# Remove each patch once the fix is available in a published gem version.
+
+module RubyLLM
+  module Streaming
+    private
+
+    # Upstream ruby_llm <= 1.15.0 assumes the SSE error chunk always has two
+    # lines ("event: error\ndata: {...}") and uses a fixed index [1], which
+    # raises NoMethodError when some providers (e.g. Qwen) return a single-line
+    # chunk ("data: {...}").  This patch finds the data line by content instead.
+    def handle_error_chunk(chunk, env)
+      data_line = chunk.split("\n").find { |l| l.start_with?("data: ") } || chunk.split("\n")[0]
+      error_data = data_line.delete_prefix("data: ")
+      parse_error_from_json(error_data, env, "Failed to parse error chunk")
+    end
+  end
+end

data/lib/phronomy/tool/mcp_tool.rb

@@ -11,10 +11,11 @@ module Phronomy
     # A Phronomy::Tool::Base subclass that wraps a tool exposed by an external
     # MCP (Model Context Protocol) server.
     #
-    # Currently supports the **stdio** transport only: the MCP server is launched
-    # as a child process and communicates via newline-delimited JSON-RPC on stdin/stdout.
-    #
-    # HTTP/SSE transport support can be added later by subclassing Transport.
+    # Supports two transport schemes:
+    # - <b>"stdio://\<command\>"</b> — spawns a child process that communicates via
+    #   newline-delimited JSON-RPC on stdin/stdout.
+    # - <b>"http://\<url\>"</b> / <b>"https://\<url\>"</b> — connects to a running
+    #   HTTP/SSE MCP server using +net/http+.
     #
     # @example
     #   web_search = Phronomy::Tool::McpTool.from_server(
@@ -31,6 +32,7 @@ module Phronomy
         # @param server_uri [String] URI of the MCP server.
         #   Supported schemes:
         #   - "stdio://<command>"  — spawn a child process
+        #   - "http://<url>" / "https://<url>" — connect to an HTTP/SSE server
         # @param tool_name [String] the tool name as registered in the MCP server
         # @return [McpTool] a configured subclass instance ready for use with an Agent
         def from_server(server_uri, tool_name:)
@@ -87,7 +89,6 @@ module Phronomy
           # Split the command string into an argv array so that Open3 executes
           # it directly without going through the shell, preventing injection.
           @command = Shellwords.split(command)
-          @actor = Phronomy::Actor.new
           @stdin = nil
           @stdout = nil
           @stderr = nil
@@ -97,19 +98,17 @@ module Phronomy
 
         # Shut down the child process and close its IO streams.
         def close
-          stderr_thread, wait_thr = @actor.call do
-            @stdin&.close
-            @stdout&.close
-            @stderr&.close
-            @stdin = nil
-            @stdout = nil
-            @stderr = nil
-            t = [@stderr_thread, @wait_thr]
-            @stderr_thread = nil
-            @wait_thr = nil
-            t
-          end
-          # Join outside the Actor to avoid blocking the Actor thread on slow joins.
+          @stdin&.close
+          @stdout&.close
+          @stderr&.close
+          @stdin = nil
+          @stdout = nil
+          @stderr = nil
+          stderr_thread = @stderr_thread
+          wait_thr = @wait_thr
+          @stderr_thread = nil
+          @wait_thr = nil
+          # Join outside the lock to avoid blocking on slow joins.
           stderr_thread&.join(1)
           wait_thr&.join(5)
         end
@@ -168,14 +167,12 @@ module Phronomy
         end
 
         def rpc_call(method, params)
-          @actor.call do
-            ensure_started!
-            payload = JSON.generate(jsonrpc: "2.0", id: SecureRandom.uuid, method: method, params: params)
-            @stdin.puts(payload)
-            raw = @stdout.gets
-            raise Phronomy::ToolError, "MCP server closed the connection unexpectedly" if raw.nil?
-            JSON.parse(raw)
-          end
+          ensure_started!
+          payload = JSON.generate(jsonrpc: "2.0", id: SecureRandom.uuid, method: method, params: params)
+          @stdin.puts(payload)
+          raw = @stdout.gets
+          raise Phronomy::ToolError, "MCP server closed the connection unexpectedly" if raw.nil?
+          JSON.parse(raw)
         end
 
         def parse_schema_params(properties)

data/lib/phronomy/tracing/langfuse_tracer.rb

@@ -36,7 +36,6 @@ module Phronomy
         @secret_key = secret_key
         @host = host.chomp("/")
         @http = nil
-        @actor = Phronomy::Actor.new
       end
 
       # Returns a plain Hash that records the span start state.
@@ -90,13 +89,11 @@ module Phronomy
         req["Authorization"] = "Basic #{Base64.strict_encode64("#{@public_key}:#{@secret_key}")}"
         req.body = JSON.generate({batch: events})
 
-        @actor.call do
-          @http ||= build_http(uri)
-          @http.request(req)
-        end
+        @http ||= build_http(uri)
+        @http.request(req)
       rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
         # Connection was reset; drop the cached connection and warn.
-        @actor.call { @http = nil }
+        @http = nil
         warn "[Phronomy::LangfuseTracer] Ingestion failed: #{e.class}: #{e.message}"
         nil
       rescue => e

data/lib/phronomy/trust_pipeline.rb

@@ -94,7 +94,6 @@ module Phronomy
       @threshold = confidence_threshold.to_f
       @max_iterations = max_iterations.to_i
       @input_delimiter = input_delimiter
-      @actor = Phronomy::Actor.new
       @compiled_graph = nil
     end
 
@@ -125,7 +124,7 @@ module Phronomy
 
     # Returns the compiled workflow, building and caching it on first call.
     def compiled_graph
-      @actor.call { @compiled_graph ||= build_workflow }
+      @compiled_graph ||= build_workflow
     end
 
     def build_workflow

data/lib/phronomy/vector_store/redis_search.rb

@@ -38,7 +38,7 @@ module Phronomy
         @index_name = index_name
         @dimension = dimension
         @index_created = false
-        @actor = Phronomy::Actor.new
+        @mutex = Mutex.new
       end
 
       # @param id        [String]
@@ -80,7 +80,7 @@ module Phronomy
       end
 
       def clear
-        @actor.call do
+        @mutex.synchronize do
           begin
             @redis.call("FT.DROPINDEX", @index_name, "DD")
           rescue => e
@@ -94,8 +94,8 @@ module Phronomy
       private
 
       def ensure_index!(dim)
-        @actor.call do
-          next if @index_created
+        @mutex.synchronize do
+          return if @index_created
 
           @dimension ||= dim
           begin

data/lib/phronomy/version.rb

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

data/lib/phronomy/workflow.rb

@@ -53,11 +53,10 @@ module Phronomy
 
     # Defines a new Workflow.
     # @param context_class [Class] class that includes Phronomy::WorkflowContext
-    # @param state_store [Object, nil] optional state store override (passed to WorkflowRunner)
     # @yield block evaluated in DSL context
     # @return [Phronomy::Workflow] compiled and ready-to-run workflow instance
-    def self.define(context_class, state_store: nil, &block)
-      builder = Builder.new(context_class, state_store: state_store)
+    def self.define(context_class, &block)
+      builder = Builder.new(context_class)
       builder.instance_eval(&block)
       builder.build
     end
@@ -110,9 +109,8 @@ module Phronomy
     class Builder
       FINISH = Phronomy::WorkflowRunner::FINISH
 
-      def initialize(context_class, state_store: nil)
+      def initialize(context_class)
         @context_class = context_class
-        @state_store = state_store
         @initial = nil
         # { node_name => callable }
         @states = {}
@@ -210,8 +208,7 @@ module Phronomy
           route_transitions: route_transitions,
           external_events: external_events,
           entry_point: @initial || nodes.keys.first,
-          wait_state_names: @wait_state_names,
-          state_store: @state_store
+          wait_state_names: @wait_state_names
         )
 
         Workflow.new(runner)

data/lib/phronomy/workflow_runner.rb

@@ -38,7 +38,7 @@ module Phronomy
 
     def initialize(state_class:, nodes:, after_transitions:, route_transitions:,
       external_events:, entry_point:, wait_state_names: [],
-      before_callbacks: {}, after_callbacks: {}, state_store: nil)
+      before_callbacks: {}, after_callbacks: {})
       @state_class = state_class
       @nodes = nodes
       @after_transitions = after_transitions  # { from => to }
@@ -48,7 +48,6 @@ module Phronomy
       @wait_state_names = wait_state_names
       @before_callbacks = before_callbacks.dup
       @after_callbacks = after_callbacks.dup
-      @state_store_override = state_store
       @phase_machine_class = build_phase_machine_class
     end
 
@@ -134,10 +133,6 @@ module Phronomy
 
     private
 
-    def state_store
-      @state_store_override || Phronomy.configuration.default_state_store
-    end
-
     def run_graph(state, from_node: nil, recursion_limit: 25, &event_block)
       current_node = from_node || @entry_point
       tracker = new_phase_machine(current_node)
@@ -153,7 +148,6 @@ module Phronomy
         # Auto-halt at wait states: save context and return to caller.
         if @wait_state_names.include?(current_node)
           state.set_graph_metadata(thread_id: state.thread_id, phase: current_node)
-          state_store&.save(state)
           return state
         end
 
@@ -195,7 +189,6 @@ module Phronomy
       end
 
       state.set_graph_metadata(thread_id: state.thread_id, phase: :__end__)
-      state_store&.save(state)
       state
     end
 

data/lib/phronomy.rb

@@ -2,6 +2,7 @@
 
 require "zeitwerk"
 require "ruby_llm"
+require_relative "phronomy/ruby_llm_patches"
 
 loader = Zeitwerk::Loader.for_gem
 loader.ignore(File.expand_path("generators", __dir__))

data/scripts/check_readme_ruby.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Extracts every ```ruby ... ``` block from README.md and runs `ruby -c` on each.
+# Exits non-zero if any block has a syntax error.
+
+require "tempfile"
+require "open3"
+
+readme_path = File.expand_path("../README.md", __dir__)
+readme = File.read(readme_path)
+blocks = readme.scan(/^```ruby\n(.*?)^```/m).map.with_index(1) { |(code), i| [i, code] }
+
+puts "Checking #{blocks.size} Ruby code blocks in README.md..."
+
+failures = []
+
+blocks.each do |index, code|
+  Tempfile.create(["readme_block_#{index}", ".rb"]) do |f|
+    f.write(code)
+    f.flush
+    stdout, status = Open3.capture2e("ruby", "-c", f.path)
+    if status.success?
+      puts "  OK   block ##{index}"
+    else
+      failures << index
+      puts "  FAIL block ##{index}"
+      puts stdout.gsub(f.path, "block ##{index}")
+    end
+  end
+end
+
+if failures.empty?
+  puts "All #{blocks.size} Ruby code blocks passed syntax check."
+  exit 0
+else
+  puts "\n#{failures.size} block(s) failed syntax check: #{failures.join(", ")}"
+  exit 1
+end