phronomy 0.27.0 → 0.29.0

data/lib/phronomy/vector_store/{redis_search.rb → backends/redis_search.rb}

@@ -8,7 +8,7 @@ module Phronomy
     #
     # Requires:
     #   - The +redis+ gem (add to your Gemfile)
-    #   - A Redis server with the RediSearch (RedisSearch) module enabled
+    #   - A RESP2 Redis client and a server with the RediSearch module enabled
     #     (or Redis Stack which bundles RediSearch)
     #
     # Vectors are stored as FLOAT32 binary blobs in Redis Hash fields and
@@ -46,17 +46,17 @@ module Phronomy
         @mutex = Mutex.new
       end
 
+      protected
+
       # @param id                 [String]
       # @param embedding          [Array<Float>]
       # @param metadata           [Hash]
       # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil]
       # @api public
-      def add(id:, embedding:, metadata: {}, cancellation_token: nil)
-        cancellation_token&.raise_if_cancelled!
+      def perform_add(id:, embedding:, metadata: {}, cancellation_token: nil)
         # Establish expected dimension on first add (not race-free for concurrent
-        # first adds), then validate, then create/reuse the index.
+        # first adds), then create/reuse the index. Base has validated the input.
         @dimension ||= embedding.size
-        validate_embedding_dimension!(embedding, @dimension)
         ensure_index!(@dimension)
         @redis.call(
           "HSET", "#{DOC_PREFIX}#{id}",
@@ -71,20 +71,17 @@ module Phronomy
       # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil]
       # @return [Array<Hash>] sorted by descending similarity score
       # @api public
-      def search(query_embedding:, k: 5, cancellation_token: nil)
-        cancellation_token&.raise_if_cancelled!
+      def perform_search(query_embedding:, k: 5, cancellation_token: nil)
         # search never establishes dimension.  If dimension is unknown and the
         # index has not been created yet, there are no documents to return.
         return [] if @dimension.nil? && !@index_created
 
-        validate_embedding_dimension!(query_embedding, @dimension)
         ensure_index!(@dimension)
-        k_safe = validate_k!(k)
         blob = pack_vector(query_embedding)
 
         raw = @redis.call(
           "FT.SEARCH", @index_name,
-          "*=>[KNN #{k_safe} @embedding $BLOB AS score]",
+          "*=>[KNN #{k} @embedding $BLOB AS score]",
           "PARAMS", 2, "BLOB", blob,
           "SORTBY", "score",
           "RETURN", 2, "score", "metadata",
@@ -94,26 +91,26 @@ module Phronomy
         parse_results(raw)
       end
 
-      def remove(id:)
+      def perform_remove(id:)
         @redis.call("DEL", "#{DOC_PREFIX}#{id}")
         self
       end
 
       # Returns the number of documents indexed.
       # Queries FT.INFO when the index has been created; returns 0 otherwise.
-      def size
+      def perform_size
         return 0 unless @index_created
 
-        raw = @redis.call("FT.INFO", @index_name)
-        return 0 unless raw.is_a?(Array)
-
-        idx = raw.index("num_docs")
-        idx ? raw[idx + 1].to_i : 0
-      rescue
-        0
+        fields = parse_fields(@redis.call("FT.INFO", @index_name), "FT.INFO")
+        count = fields["num_docs"]
+        count = Integer(count, 10) if count.is_a?(String) && count.match?(/\A\d+\z/)
+        unless count.is_a?(Integer) && count >= 0
+          raise InvalidResultError, "Redis FT.INFO requires a non-negative integer num_docs"
+        end
+        count
       end
 
-      def clear
+      def perform_clear
         @mutex.synchronize do
           begin
             @redis.call("FT.DROPINDEX", @index_name, "DD")
@@ -125,6 +122,11 @@ module Phronomy
         self
       end
 
+      # @api public
+      def embedding_dimension
+        @dimension
+      end
+
       private
 
       def ensure_index!(dim)
@@ -160,33 +162,68 @@ module Phronomy
       #
       # Redis FT.SEARCH returns: [count, key1, [field, value, ...], key2, ...]
       def parse_results(raw)
-        return [] if raw.nil? || !raw.is_a?(Array) || raw.size < 2
+        unless raw.is_a?(Array) && raw.size.odd? && raw.first.is_a?(Integer) &&
+            raw.first >= (raw.size - 1) / 2 && raw.first.zero? == (raw.size == 1)
+          raise InvalidResultError, "Redis FT.SEARCH requires a count and document/field pairs"
+        end
 
         results = []
-        i = 1
-        while i < raw.size
-          key = raw[i]
-          fields = raw[i + 1]
-          i += 2
-
-          next unless fields.is_a?(Array)
-
-          field_hash = fields.each_slice(2).to_h
-          score_str = field_hash["score"]
-          metadata_str = field_hash["metadata"]
-
-          next if score_str.nil?
+        raw.drop(1).each_slice(2) do |key, fields|
+          unless key.is_a?(String) && key.start_with?(DOC_PREFIX)
+            raise InvalidResultError, "Redis FT.SEARCH returned an invalid document key"
+          end
+          # Redis documents this null content when a key expires/is updated
+          # during the search. The key remains in the total count.
+          next if fields.nil?
 
-          id = key.to_s.delete_prefix(DOC_PREFIX)
+          field_hash = parse_fields(fields, "FT.SEARCH")
+          id = key.delete_prefix(DOC_PREFIX)
           # RediSearch returns cosine distance (0=identical, 2=opposite);
           # convert to cosine similarity for consistency with other backends.
-          score = 1.0 - score_str.to_f
-          metadata = metadata_str ? JSON.parse(metadata_str, symbolize_names: true) : {}
+          score = 1.0 - parse_distance(field_hash["score"])
+          metadata = parse_metadata(field_hash["metadata"])
 
           results << {id: id, score: score, metadata: metadata}
         end
         results
       end
+
+      # RESP2 field/value decoding belongs to this backend, not the Contract.
+      def parse_fields(raw, command)
+        unless raw.is_a?(Array) && raw.size.even?
+          raise InvalidResultError, "Redis #{command} requires field/value pairs"
+        end
+        raw.each_slice(2).each_with_object({}) do |(key, value), fields|
+          unless key.is_a?(String) && !fields.key?(key)
+            raise InvalidResultError, "Redis #{command} returned an invalid or duplicate field"
+          end
+          fields[key] = value
+        end
+      end
+
+      def parse_distance(raw)
+        valid = (raw.is_a?(String) && raw.match?(/\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/)) ||
+          (raw.is_a?(Numeric) && raw.real?)
+        value = Float(raw, exception: false) if valid
+        unless value&.finite?
+          raise InvalidResultError, "Redis FT.SEARCH requires a finite numeric score"
+        end
+        value
+      end
+
+      def parse_metadata(raw)
+        return {} if raw.nil?
+        unless raw.is_a?(String)
+          raise InvalidResultError, "Redis metadata must contain a JSON object"
+        end
+        parsed = JSON.parse(raw, symbolize_names: true)
+        unless parsed.is_a?(Hash)
+          raise InvalidResultError, "Redis metadata must contain a JSON object"
+        end
+        parsed
+      rescue JSON::ParserError
+        raise InvalidResultError, "Redis metadata contains invalid JSON"
+      end
     end
   end
 end

data/lib/phronomy/vector_store/base.rb

@@ -1,87 +1,156 @@
 # frozen_string_literal: true
 
+require_relative "invalid_result_error"
+
 module Phronomy
   module VectorStore
-    # Public extension SPI for vector stores.
-    #
-    # Backends implement the synchronous add/search/remove/clear/size contract.
-    # Phronomy supplies async convenience methods through {AsyncBackend}; blocking
-    # backend work is offloaded through the framework-owned bounded OffloadPool.
-    #
+    # Owns synchronous operations, input validation and the public result shape.
+    # Backends implement protected perform_* operations and embedding_dimension.
+    # No execution client, SDK or embedding provider is selected by this class.
     # @api public
     class Base
-      include AsyncBackend
-
-      # Add a document with its vector embedding.
-      #
-      # @param id                 [String] unique document identifier
-      # @param embedding          [Array<Float>] vector embedding
-      # @param metadata           [Hash] arbitrary metadata
-      # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil]
+      # Validate before invoking the backend. Cancellation is checked before the
+      # write, never reported after a successful write. No operation is retried.
+      # @param id [String]
+      # @param embedding [Array<Numeric>]
+      # @param metadata [Hash]
+      # @param cancellation_token [#raise_if_cancelled!, nil]
+      # @return [self]
       # @api public
       def add(id:, embedding:, metadata: {}, cancellation_token: nil)
         cancellation_token&.raise_if_cancelled!
-        raise NotImplementedError, "#{self.class}#add is not implemented"
+        validate_id!(id)
+        raise ArgumentError, "metadata must be a Hash" unless metadata.is_a?(Hash)
+        vector = validate_vector!(embedding)
+        perform_add(id: id, embedding: vector, metadata: metadata, cancellation_token: cancellation_token)
+        self
       end
 
-      # Return the k most similar documents to the query embedding.
-      #
-      # @param query_embedding    [Array<Float>]
-      # @param k                  [Integer] number of results
-      # @param cancellation_token [Phronomy::Concurrency::CancellationToken, nil]
-      # @return [Array<Hash>] each element: { id:, score:, metadata: }
+      # Return at most k results ordered by descending similarity. Malformed
+      # backend output raises InvalidResultError; transport errors propagate.
+      # @param query_embedding [Array<Numeric>]
+      # @param k [Integer, String] positive integer or its decimal string
+      # @param cancellation_token [#raise_if_cancelled!, nil]
+      # @return [Array<Hash>]
       # @api public
       def search(query_embedding:, k: 5, cancellation_token: nil)
         cancellation_token&.raise_if_cancelled!
-        raise NotImplementedError, "#{self.class}#search is not implemented"
+        limit = validate_k!(k)
+        vector = validate_vector!(query_embedding)
+        results = perform_search(query_embedding: vector, k: limit, cancellation_token: cancellation_token)
+        validate_results!(results, limit)
+        results
       end
 
-      # Remove a single document by id.
-      #
-      # @param id [String] document identifier
+      # Remove a document; an absent id is a successful no-op.
+      # @param id [String]
+      # @return [self]
       # @api public
       def remove(id:)
-        raise NotImplementedError, "#{self.class}#remove is not implemented"
+        validate_id!(id)
+        perform_remove(id: id)
+        self
       end
 
-      # Remove all documents.
+      # Clear documents without changing the configured dimension.
+      # @return [self]
       # @api public
       def clear
-        raise NotImplementedError, "#{self.class}#clear is not implemented"
+        perform_clear
+        self
       end
 
-      # Return the number of documents stored.
-      #
-      # @return [Integer]
+      # @return [Integer] non-negative document count
       # @api public
       def size
-        raise NotImplementedError, "#{self.class}#size is not implemented"
+        count = perform_size
+        unless count.is_a?(Integer) && count >= 0
+          raise InvalidResultError, "size must return a non-negative Integer"
+        end
+        count
+      end
+
+      protected
+
+      # @return [Integer, nil] nil delegates dimension enforcement to the backend
+      # @api public
+      def embedding_dimension
+        nil
+      end
+
+      # Storage extension point; inputs have passed common validation.
+      # @api public
+      def perform_add(id:, embedding:, metadata:, cancellation_token:)
+        raise NotImplementedError, "#{self.class}#perform_add is not implemented"
+      end
+
+      # Search extension point; return the documented result hashes in order.
+      # @api public
+      def perform_search(query_embedding:, k:, cancellation_token:)
+        raise NotImplementedError, "#{self.class}#perform_search is not implemented"
+      end
+
+      # @api public
+      def perform_remove(id:)
+        raise NotImplementedError, "#{self.class}#perform_remove is not implemented"
+      end
+
+      # @api public
+      def perform_clear
+        raise NotImplementedError, "#{self.class}#perform_clear is not implemented"
+      end
+
+      # @api public
+      def perform_size
+        raise NotImplementedError, "#{self.class}#perform_size is not implemented"
       end
 
       private
 
-      # Validates that embedding has the expected dimension.
-      # Raises ArgumentError if sizes differ.
-      # A nil expected_dimension is a no-op (dimension not yet established).
-      def validate_embedding_dimension!(embedding, expected_dimension)
-        return unless expected_dimension
+      def validate_id!(id)
+        raise ArgumentError, "id must be a String" unless id.is_a?(String)
+      end
 
-        actual = embedding.size
-        return if actual == expected_dimension
+      def finite_real?(value)
+        value.is_a?(Numeric) && value.real? && value.finite? && value.to_f.finite?
+      end
 
-        raise ArgumentError,
-          "Embedding dimension mismatch: expected #{expected_dimension}, got #{actual}"
+      def validate_vector!(embedding)
+        unless embedding.is_a?(Array) && embedding.all? { |value| finite_real?(value) }
+          raise ArgumentError, "embedding must be an Array of finite real numbers"
+        end
+        dimension = embedding_dimension
+        if dimension && embedding.size != dimension
+          raise ArgumentError, "Embedding dimension mismatch: expected #{dimension}, got #{embedding.size}"
+        end
+        embedding.map(&:to_f)
       end
 
-      # Validates that k is a positive integer.
-      # Accepts any value accepted by Integer() (e.g. "5"), but raises
-      # ArgumentError for non-integer strings, zero, and negative values.
       def validate_k!(k)
-        int_k = Integer(k)
-        raise ArgumentError, "k must be a positive integer, got #{int_k}" unless int_k >= 1
-        int_k
-      rescue ArgumentError => e
-        raise ArgumentError, "k must be a positive integer: #{e.message}"
+        valid = k.is_a?(Integer) || (k.is_a?(String) && k.match?(/\A\+?\d+\z/))
+        unless valid
+          raise ArgumentError, "k must be a positive integer"
+        end
+        value = k.is_a?(String) ? Integer(k, 10) : k
+        raise ArgumentError, "k must be a positive integer" unless value >= 1
+        value
+      end
+
+      def validate_results!(results, limit)
+        unless results.is_a?(Array) && results.size <= limit
+          raise InvalidResultError, "search must return an Array with at most k results"
+        end
+        previous = Float::INFINITY
+        results.each do |result|
+          unless result.is_a?(Hash) && result[:id].is_a?(String) &&
+              result[:metadata].is_a?(Hash) && finite_real?(result[:score])
+            raise InvalidResultError, "search results require a String id, finite score and Hash metadata"
+          end
+          if result[:score] > previous
+            raise InvalidResultError, "search results must be ordered by descending score"
+          end
+          previous = result[:score]
+        end
       end
     end
   end

data/lib/phronomy/vector_store/invalid_result_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../common/error"
+
+module Phronomy
+  module VectorStore
+    # A backend could not produce a valid synchronous result. This includes
+    # malformed external responses that must not be replaced with success values.
+    # @api public
+    class InvalidResultError < Phronomy::Error; end
+  end
+end

data/lib/phronomy/vector_store.rb

@@ -1,23 +1,8 @@
 # frozen_string_literal: true
 
 module Phronomy
-  # Vector store infrastructure: backends, embeddings adapters, document loaders,
-  # and text splitters.
-  #
-  # Sub-namespaces are auto-loaded by Zeitwerk:
-  #   Phronomy::VectorStore::Base
-  #   Phronomy::VectorStore::InMemory
-  #   Phronomy::VectorStore::Pgvector
-  #   Phronomy::VectorStore::RedisSearch
-  #   Phronomy::VectorStore::Embeddings::Base
-  #   Phronomy::VectorStore::Embeddings::RubyLLMEmbeddings
-  #   Phronomy::VectorStore::Loader::Base
-  #   Phronomy::VectorStore::Loader::PlainTextLoader
-  #   Phronomy::VectorStore::Loader::MarkdownLoader
-  #   Phronomy::VectorStore::Loader::CsvLoader
-  #   Phronomy::VectorStore::Splitter::Base
-  #   Phronomy::VectorStore::Splitter::FixedSizeSplitter
-  #   Phronomy::VectorStore::Splitter::RecursiveSplitter
+  # Synchronous vector search/storage contract, its backends and execution client.
+  # Embeddings and Documents are independent Phronomy responsibilities.
   module VectorStore
   end
 end

data/lib/phronomy/version.rb

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

data/lib/phronomy/workflow/completion.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Phronomy
+  class Workflow
+    # Workflow definition contract shared with its execution runner.
+    # @api private
+    module Completion
+      FINISH = :__finish__
+    end
+  end
+end

data/lib/phronomy/workflow/execution/workflow.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 require_relative "workflow_runner"
-require_relative "../../engine/runnable"
+require_relative "../../execution/runnable"
 
 module Phronomy
   # StateChart-style Workflow definition DSL.
@@ -67,7 +67,7 @@ module Phronomy
     def _apply_invocation_context(config, invocation_context)
       effective = config.merge(invocation_context: invocation_context)
       if effective[:cancellation_token].nil?
-        token = invocation_context.effective_timeout_token
+        token = Phronomy::InvocationControls.effective_timeout_token(invocation_context)
         effective = effective.merge(cancellation_token: token) if token
       end
       effective
@@ -85,6 +85,7 @@ module Phronomy
         @exit_actions = {}
         @transitions = []
         @wait_state_names = []
+        @task_states = {}
       end
 
       def initial(state_name) # rubocop:disable Style/TrivialAccessors
@@ -94,9 +95,10 @@ module Phronomy
       # Declares a Workflow state.
       #
       # Entry actions are synchronous Run-to-Completion callbacks. To start
-      # asynchronous work, register its listener/callback inside the action and
-      # return the context or nil. Returning Phronomy::TaskResult is an error.
+      # asynchronous work owned by this state, use task_state. Ordinary actions
+      # return the context or nil; returning Phronomy::TaskResult is an error.
       def state(name, action: nil)
+        reject_task_state_overlap!(name)
         @declared_states << name
         entry(name, action) if action
       end
@@ -110,9 +112,30 @@ module Phronomy
       end
 
       def wait_state(name)
+        reject_task_state_overlap!(name)
         @wait_state_names << name
       end
 
+      # Starts one asynchronous operation on state entry and advances only
+      # after its successful result has been applied on the execution owner.
+      # Task completion is correlated to this state entry, not a durable ID.
+      # @param name [Symbol] state name
+      # @param start [#call] short callback accepting a context snapshot and returning TaskResult
+      # @param apply [#call] short callback accepting current context and value; returns context or nil
+      # @return [void]
+      # @api public
+      def task_state(name, start:, apply:)
+        unless name.is_a?(Symbol) && start.respond_to?(:call) && apply.respond_to?(:call)
+          raise ArgumentError, "task_state requires a Symbol name and callable start/apply"
+        end
+        if @declared_states.include?(name) || @wait_state_names.include?(name)
+          raise ArgumentError, "Workflow state #{name.inspect} is already declared"
+        end
+        @declared_states << name
+        @task_states[name] = {start: start, apply: apply}.freeze
+        nil
+      end
+
       # Declares a transition.
       #
       # Guards and actions may accept either (context) or (context, event).
@@ -121,7 +144,7 @@ module Phronomy
       # They may start asynchronous work and register listeners, but returning
       # Phronomy::TaskResult is an error; completion must arrive as a later event.
       def transition(from:, to:, guard: nil, on: nil, action: nil)
-        destination = (to == :__finish__) ? FSMProtocol::FINISH : to
+        destination = to
         @transitions << {
           from: from,
           to: destination,
@@ -167,6 +190,7 @@ module Phronomy
           external_events: external_events,
           entry_point: @initial || @declared_states.first,
           wait_state_names: @wait_state_names.dup,
+          task_states: @task_states.dup.freeze,
           persistence: @persistence
         )
         Workflow.new(runner)
@@ -174,6 +198,10 @@ module Phronomy
 
       private
 
+      def reject_task_state_overlap!(name)
+        raise ArgumentError, "Workflow task_state #{name.inspect} is already declared" if @task_states.key?(name)
+      end
+
       def validate_graph!
         all_states = (@declared_states + @wait_state_names).uniq
         entry_point = @initial || @declared_states.first
@@ -186,7 +214,7 @@ module Phronomy
 
         undefined_targets = @transitions
           .map { |transition| transition[:to] }
-          .reject { |target| target == FSMProtocol::FINISH } - all_states
+          .reject { |target| target == Completion::FINISH } - all_states
         unless undefined_targets.empty?
           raise ArgumentError,
             "Workflow transition(s) reference undefined state(s): " \
@@ -207,7 +235,7 @@ module Phronomy
           current = queue.shift
           @transitions.each do |transition|
             next unless transition[:from] == current
-            next if transition[:to] == FSMProtocol::FINISH
+            next if transition[:to] == Completion::FINISH
             next if reachable.include?(transition[:to])
 
             reachable.add(transition[:to])
@@ -222,7 +250,7 @@ module Phronomy
           "[Phronomy] Workflow has unreachable state(s): " \
           "#{unreachable.sort.inspect}. These states can never be entered " \
           "from the initial state #{entry_point.inspect}."
-        logger = Phronomy.configuration.logger
+        logger = Phronomy::RuntimeSettings.current.logger
         logger ? logger.warn(message) : Kernel.warn(message)
       end
     end

data/lib/phronomy/workflow/execution/workflow_action_rules.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Phronomy
+  # Workflow's synchronous callback rules, independent of FSM representation.
+  # Guards and transition actions may receive the triggering application event;
+  # actions may initiate async work but must not return a TaskResult.
+  # @api private
+  module WorkflowActionRules
+    module_function
+
+    def allowed?(guard, context, event)
+      guard.nil? || call_with_optional_event(guard, context, event)
+    end
+
+    def transition(callable, context, event, metadata:)
+      return context if callable.nil?
+
+      result = call_with_optional_event(callable, context, event)
+      if result.is_a?(Phronomy::TaskResult)
+        raise Phronomy::InvalidAsyncTransitionActionError,
+          "Transition action " \
+            "#{metadata[:from].inspect} --#{metadata[:event].inspect}--> " \
+            "#{metadata[:to].inspect} returned Phronomy::TaskResult. " \
+            "Start the asynchronous operation, register its callback/listener, " \
+            "and return the WorkflowContext or nil."
+      end
+      workflow_context_result?(result) ? result : context
+    end
+
+    def entry(callable, context, state_name)
+      result = callable.call(context)
+      if result.is_a?(Phronomy::TaskResult)
+        raise Phronomy::InvalidAsyncEntryActionError,
+          "Entry action for state #{state_name.inspect} returned Phronomy::TaskResult. " \
+            "Start the asynchronous operation, register its callback/listener, " \
+            "and return the WorkflowContext or nil."
+      end
+      result
+    end
+
+    def apply_entry(callable, context, state_name)
+      result = entry(callable, context, state_name)
+      workflow_context_result?(result) ? result : context
+    end
+
+    def exit(callable, context, state_name)
+      result = callable.call(context)
+      if result.is_a?(Phronomy::TaskResult)
+        raise Phronomy::InvalidAsyncEntryActionError,
+          "Exit action for state #{state_name.inspect} returned Phronomy::TaskResult. " \
+            "Exit actions are synchronous Run-to-Completion callbacks."
+      end
+      nil
+    end
+
+    def call_with_optional_event(callable, context, event)
+      parameters = callable.respond_to?(:parameters) ? callable.parameters : callable.method(:call).parameters
+      (parameters.length >= 2) ? callable.call(context, event) : callable.call(context)
+    end
+    private_class_method :call_with_optional_event
+
+    def workflow_context_result?(result)
+      result.respond_to?(:set_graph_metadata)
+    end
+    private_class_method :workflow_context_result?
+  end
+end

data/lib/phronomy/workflow/execution/workflow_context.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../engine/concurrency/worker_input_restricted"
+require_relative "../../execution/concurrency/worker_input_restricted"
 
 module Phronomy
   # Module for defining Workflow context data.
@@ -138,7 +138,7 @@ module Phronomy
     # dispatch thread. All Workflow execution APIs now use that same path; there
     # is no caller-thread synchronous exception.
     def _assert_write_permitted!
-      return if Phronomy::Runtime.in_event_loop_context?
+      return if Phronomy::WaitPolicy.blocking_forbidden?
 
       raise Phronomy::WorkflowContextOwnershipError,
         "WorkflowContext fields may only be mutated from the EventLoop dispatch " \