branchproof 0.5.0 → 0.7.0

data/lib/branchproof/report.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/BlockLength
+
 require "json"
 require "pathname"
 
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
-    SCHEMA_VERSION = "1.1"
+    SCHEMA_VERSION = "1.2"
     CRITERION_VERSION = "masking_occurrence_v1"
 
     def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3, missing_only: false,
@@ -70,6 +72,31 @@ module Branchproof
       "#{prefix}#{path}: #{message}"
     end
 
+    # Returns condition-value evidence for focused renderers without exposing
+    # the report's internal document traversal or mutating saved records.
+    def condition_coverage_evidence(decision_id:, condition_id:)
+      decision = inventory_decisions.find { |item| value(item, :id).to_s == decision_id.to_s }
+      condition = Array(value(decision, :conditions)).find do |item|
+        value(item, :id).to_s == condition_id.to_s
+      end
+      coverage = value(condition_result(decision, condition), :coverage)
+      return [] unless coverage
+
+      @terminal_ids ||= terminal_ids
+      lines = Array(value(coverage, :values)).map do |entry|
+        value_label = value(entry, :value) ? "true" : "false"
+        owners = Array(value(entry, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(entry, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        "  Value #{value_label}: #{value(entry, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_values))
+      unless missing.empty?
+        lines << "  Missing values: #{missing.map { |item| item ? "true" : "false" }.join(", ")}"
+      end
+      lines
+    end
+
     def exit_code
       return 2 unless usage_valid?
 
@@ -78,7 +105,9 @@ module Branchproof
       return 1 if status == "FAILED"
       return 2 unless status == "PASSED" && value(@baseline, :finalized) == true
       return 2 if @saved_document && (value(@saved_document, :completeness) || {}).values.include?(false)
-      return 2 unless metrics[:eligible_conditions].positive?
+
+      eligible = metrics[:eligible_conditions].positive? || metrics[:eligible_alternatives].positive?
+      return 2 unless eligible
       return 2 unless valid_for_requested_level?
 
       0
@@ -93,8 +122,8 @@ module Branchproof
                 tool_version: (defined?(Branchproof::VERSION) ? Branchproof::VERSION : "unknown"),
                 criterion_version: CRITERION_VERSION, runtime: RUBY_DESCRIPTION,
                 run_ids: Array(value(@evidence, :run_ids)),
-                source_inventory: @inventory, baseline: @baseline, observations: @evidence,
-                analysis: @level == 1 ? nil : @analysis, minima: @minima, metrics: metrics,
+                source_inventory: inventory_with_default_kinds, baseline: @baseline, observations: @evidence,
+                analysis: @analysis, minima: @minima, metrics: metrics,
                 diagnostics: @diagnostics, completeness: completeness,
                 run_metadata: @run_metadata)
     end
@@ -112,11 +141,13 @@ module Branchproof
                "Analysis: #{terminal_analysis_status}",
                "Decisions: #{metrics[:supported]} supported, #{metrics[:unsupported]} excluded, " \
                "#{metrics[:unexecuted]} unexecuted (#{metrics[:discovered]} discovered)",
+               decision_kind_summary_line,
                "Observations: #{metrics[:completed]} completed, #{metrics[:aborted]} aborted, " \
                "#{metrics[:unattributed]} unattributed",
-               "Values: T=true, F=false, -=short-circuited"]
+               values_legend]
+      lines.concat(coverage_ladder_lines)
       lines << missing_summary_line if @missing_only
-      lines << "Scope: supported decisions and conditions"
+      lines << "Scope: supported decisions, conditions, and alternatives"
       lines << ""
       decisions_to_render.each { |decision| render_decision(lines, decision) }
       render_minima(lines) unless @missing_only
@@ -133,18 +164,25 @@ module Branchproof
       decision_label = "Decision #{short_id(value(decision, :id))} #{filename}:#{value(decision, :line)}"
       lines << decision_label
       lines << "  Decision: #{value(decision, :expression)}"
+      lines << "  Kind: #{decision_kind(decision)}"
+      context = value(decision, :context)
+      lines << "  Context: #{context}" unless context.nil? || context.to_s.empty?
       lines << "  Status: #{value(decision, :support_status) || "SUPPORTED"}"
-      conditions_to_render(decision).each do |condition|
-        result = condition_result(decision, condition)
-        detail = condition_detail(decision, condition, result)
-        status = if @analysis.nil? || @level == 1
-                   "NOT CALCULATED"
-                 else
-                   value(result, :status) || "NOT_PROVEN"
-                 end
-        lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
-        lines << "    #{status}#{detail}"
+      unless nonboolean_decision?(decision)
+        conditions_to_render(decision).each do |condition|
+          result = condition_result(decision, condition)
+          detail = condition_detail(decision, condition, result)
+          status = if @analysis.nil? || (@level == 1 && !coverage_available?)
+                     "NOT CALCULATED"
+                   else
+                     value(result, :status) || "NOT_PROVEN"
+                   end
+          lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
+          lines << "    #{status}#{detail}"
+          render_condition_coverage(lines, decision, condition, result) if @level >= 2 && coverage_available?
+        end
       end
+      render_decision_coverage(lines, decision) if coverage_available?
       vectors_to_render(decision).each do |vector|
         values = Array(value(vector, :values)).map do |item|
           if item.nil?
@@ -155,13 +193,136 @@ module Branchproof
         end.join
         owners = Array(value(vector, :test_ids)).map { |test_id| test_label(test_id) }
         owners << "unattributed" if value(vector, :unattributed_count).to_i.positive?
-        vector_label = "  Vector #{short_id(value(vector, :id))} [#{values}] => " \
-                       "#{value(vector, :outcome) ? "T" : "F"}"
+        vector_label = if nonboolean_decision?(decision)
+                         selected = Array(value(vector, :values)).each_with_index.filter_map do |item, index|
+                           next unless item
+
+                           alternative = Array(value(decision, :alternatives))[index]
+                           value(alternative, :expression) || "alternative #{index}"
+                         end
+                         "  Vector #{short_id(value(vector, :id))} [#{values}] => selected: #{selected.join(", ")}"
+                       else
+                         "  Vector #{short_id(value(vector,
+                                                    :id))} [#{values}] => " + (if value(vector,
+                                                                                        :outcome)
+                                                                                 "T"
+                                                                               else
+                                                                                 "F"
+                                                                               end).to_s
+                       end
         lines << "#{vector_label} owners=#{owners.join(", ")}"
       end
       lines << ""
     end
 
+    def coverage_status_label(status)
+      { "covered" => "PASS", "partial" => "FAIL", "unexecuted" => "UNEXECUTED", "unsupported" => "EXCLUDED" }.fetch(
+        status.to_s.downcase, status.to_s.upcase
+      )
+    end
+
+    def render_decision_coverage(lines, decision)
+      if nonboolean_decision?(decision)
+        render_alternative_coverage(lines, decision)
+        return
+      end
+
+      decision_coverage = value(value(analysis_for(decision), :coverage), :decision)
+      all_coverage = value(analysis_for(decision), :coverage) || {}
+      statuses = [["D", :decision], ["C", :condition], ["C/D", :condition_decision],
+                  ["MC/DC", :mcdc]].filter_map do |label, key|
+        row = value(all_coverage, key)
+        status = value(row, :status)
+        status ? criterion_status_text(label, row) : nil
+      end
+      lines << "  Coverage: #{statuses.join(", ")}" unless statuses.empty?
+      coverage = decision_coverage
+      return unless coverage
+
+      return unless @level >= 2
+
+      Array(value(coverage, :outcomes)).each do |outcome|
+        value_label = value(outcome, :value) ? "true" : "false"
+        owners = Array(value(outcome, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(outcome, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        lines << "  Outcome #{value_label}: #{value(outcome, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_outcomes))
+      return if missing.empty?
+
+      lines << "  Missing decision outcomes: #{missing.map do |item|
+        item ? "true" : "false"
+      end.join(", ")}"
+    end
+
+    def render_alternative_coverage(lines, decision)
+      coverage = value(value(analysis_for(decision), :coverage), :alternative) || {}
+      status = value(coverage, :status)
+      required = value(coverage, :required_alternatives) || Array(value(decision, :alternatives)).length
+      covered = value(coverage, :covered_alternatives) || 0
+      lines << "  Alternatives: #{status || "NOT_CALCULATED"} (#{covered}/#{required})"
+      lines << "  MC/DC: N/A (not applicable)"
+      rows = Array(value(coverage, :alternatives))
+      rows_by_id = rows.to_h { |row| [value(row, :alternative_id).to_s, row] }
+      alternatives_to_render(decision).each do |alternative|
+        id = value(alternative, :id)
+        row = rows_by_id[id.to_s] || {}
+        lines << "  Alternative #{value(alternative, :index)}: #{value(alternative, :expression)}"
+        render_alternative_state(lines, "Selected", value(row, :selected)) if @level >= 2
+        render_alternative_state(lines, "Not selected", value(row, :not_selected)) if @level >= 2
+        render_alternative_state(lines, "Skipped", value(row, :skipped)) if @level >= 2
+      end
+      missing = Array(value(coverage, :missing_alternatives))
+      return if missing.empty?
+
+      labels = missing.map do |id|
+        alternative = Array(value(decision, :alternatives)).find { |item| value(item, :id).to_s == id.to_s }
+        value(alternative, :expression) || short_id(id)
+      end
+      label = labels.join(", ")
+      lines << "  Missing alternatives: #{label}"
+      lines << "  Need selection of: #{label}"
+    end
+
+    def render_alternative_state(lines, label, evidence)
+      evidence ||= {}
+      owners = Array(value(evidence, :test_ids)).map { |id| test_label(id) }
+      owners << "unattributed" if value(evidence, :unattributed_count).to_i.positive?
+      owners = owners.uniq
+      status = if value(evidence, :observed)
+                 "observed"
+               elsif label == "Selected"
+                 "missing"
+               else
+                 "none recorded"
+               end
+      detail = owners.empty? ? "none recorded" : owners.join(", ")
+      lines << "    #{label}: #{status}; tests: #{detail}"
+    end
+
+    def render_condition_coverage(lines, _decision, condition, result)
+      coverage = value(result, :coverage)
+      return unless coverage
+
+      values = Array(value(coverage, :values))
+      return if values.empty?
+
+      values.each do |entry|
+        value_label = value(entry, :value) ? "true" : "false"
+        owners = Array(value(entry, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(entry, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        lines << "    Value #{value_label}: #{value(entry, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_values))
+      return if missing.empty?
+
+      lines << "    Missing values for #{value(condition, :expression)}: #{missing.map do |item|
+        item ? "true" : "false"
+      end.join(", ")}"
+    end
+
     def render_minima(lines)
       rows = Array(@minima).map do |minimum|
         objective = value(minimum, :objective)
@@ -189,19 +350,19 @@ module Branchproof
     end
 
     def terminal_coverage_label
-      return "not calculated" if @analysis.nil? || @level == 1
+      return "not calculated" if @analysis.nil?
 
       coverage_label
     end
 
     def terminal_coverage_line
-      return "MC/DC: not calculated" if @analysis.nil? || @level == 1
+      return "MC/DC: not calculated" if @analysis.nil?
 
       "MC/DC: #{terminal_coverage_label} (#{metrics[:proven]}/#{metrics[:eligible_conditions]} conditions proven)"
     end
 
     def terminal_analysis_status
-      return "NOT CALCULATED" if @analysis.nil? || @level == 1
+      return "NOT CALCULATED" if @analysis.nil?
 
       analysis_status
     end
@@ -434,23 +595,73 @@ module Branchproof
       vectors.find { |vector| value(vector, :id).to_s == id }
     end
 
+    def values_legend
+      return "Values: T=true, F=false, -=short-circuited" unless inventory_decisions.any? do |decision|
+        nonboolean_decision?(decision)
+      end
+
+      "Values: Boolean T=true/F=false; flow T=selected, F=not-selected, -=skipped"
+    end
+
+    def inventory_with_default_kinds
+      decisions = inventory_decisions.map do |decision|
+        next decision if value(decision, :kind)
+
+        decision.respond_to?(:key?) ? decision.merge(kind: "boolean") : decision
+      end
+      return @inventory unless value(@inventory, :decisions)
+
+      @inventory.merge(decisions: decisions)
+    end
+
+    def decision_kind(decision)
+      kind = value(decision, :kind).to_s
+      kind.empty? ? "boolean" : kind
+    end
+
+    def nonboolean_decision?(decision)
+      %w[implicit multiway pattern exception].include?(decision_kind(decision))
+    end
+
+    def decision_kind_summary_line
+      counts = metrics[:kind_counts]
+      return "Decision kinds: none" if counts.empty?
+
+      contexts = metrics[:context_counts]
+      suffix = if contexts.empty?
+                 ""
+               else
+                 "; contexts: #{contexts.map do |context, count|
+                   "#{context}=#{count}"
+                 end.join(", ")}"
+               end
+      "Decision kinds: #{counts.map { |kind, count| "#{kind}=#{count}" }.join(", ")}#{suffix}"
+    end
+
     def metrics
       decisions = inventory_decisions
       unsupported, supported = decisions.partition { |decision| unsupported?(decision) }
       eligible = supported.sum { |decision| Array(value(decision, :conditions)).length }
       observed = vectors.map { |vector| value(vector, :decision_id).to_s }.uniq
       proven = @analysis ? value(@analysis, :proven_count).to_i : 0
+      kind_counts = decisions.group_by { |decision| decision_kind(decision) }.transform_values(&:length)
+      context_counts = decisions.group_by { |decision| value(decision, :context).to_s }
+      context_counts = context_counts.reject { |context, _| context.empty? }.transform_values(&:length)
       { discovered: decisions.length, supported: supported.length, unsupported: unsupported.length,
         unsupported_conditions: unsupported.sum do |decision|
           discovered_conditions(decision)
         end, eligible_conditions: eligible,
         opaque: decisions.sum { |decision| Array(value(decision, :opaque_ranges)).length },
         unexecuted: supported.count { |decision| !observed.include?(value(decision, :id).to_s) },
+        eligible_alternatives: supported.sum do |decision|
+          nonboolean_decision?(decision) ? Array(value(decision, :alternatives)).length : 0
+        end,
         completed: vectors.sum do |vector|
           value(vector, :count).to_i
         end, aborted: numeric_hash_value(@evidence, :abort_counts),
         unattributed: vectors.sum { |vector| value(vector, :unattributed_count).to_i }, limited: incomplete? ? 1 : 0,
-        proven: proven, percentage: percentage(eligible, proven) }
+        proven: proven, percentage: percentage(eligible, proven), kind_counts: kind_counts,
+        decision_kinds: kind_counts, context_counts: context_counts }
     end
 
     def completeness
@@ -473,7 +684,7 @@ module Branchproof
     end
 
     def valid_for_requested_level?
-      return completeness[:observation] && completeness[:attribution] if @level == 1
+      return completeness[:observation] && completeness[:attribution] if @level == 1 && @analysis.nil?
 
       completeness.values.all? { |item| item == true }
     end
@@ -486,13 +697,14 @@ module Branchproof
     end
 
     def analysis_status
-      return "NOT_REQUESTED" if @analysis.nil? || @level == 1
+      return "NOT_REQUESTED" if @analysis.nil?
 
       valid_for_requested_level? ? "COMPLETE" : "PARTIAL"
     end
 
     def incomplete?
-      !completeness[:observation] || !completeness[:attribution] || (@level > 1 && !completeness[:analysis])
+      !completeness[:observation] || !completeness[:attribution] ||
+        (analysis_available? && !completeness[:analysis])
     end
 
     def vectors_for(decision)
@@ -507,24 +719,108 @@ module Branchproof
 
       inventory_decisions
         .reject { |decision| unsupported?(decision) }
-        .select { |decision| conditions_to_render(decision).any? }
+        .select do |decision|
+          nonboolean_decision?(decision) ? missing_alternatives_for(decision).any? : conditions_to_render(decision).any?
+        end
+    end
+
+    def alternatives_to_render(decision)
+      alternatives = Array(value(decision, :alternatives))
+      return alternatives unless @missing_only && analysis_available?
+
+      missing_ids = missing_alternatives_for(decision).map(&:to_s)
+      alternatives.select { |alternative| missing_ids.include?(value(alternative, :id).to_s) }
+    end
+
+    def missing_alternatives_for(decision)
+      coverage = value(value(analysis_for(decision), :coverage), :alternative)
+      Array(value(coverage, :missing_alternatives))
     end
 
     def conditions_to_render(decision)
       conditions = Array(value(decision, :conditions))
       return conditions unless @missing_only && analysis_available?
 
-      conditions.reject { |condition| value(condition_result(decision, condition), :status).to_s.upcase == "PROVEN" }
+      conditions.reject do |condition|
+        value(condition_result(decision, condition), :status).to_s.upcase == "PROVEN"
+      end
     end
 
     def vectors_to_render(decision)
       return vectors_for(decision) unless @missing_only
+      return [] if nonboolean_decision?(decision)
 
       []
     end
 
     def analysis_available?
-      !@analysis.nil? && @level > 1
+      !@analysis.nil?
+    end
+
+    def coverage_available?
+      analysis_available? && !value(@analysis, :coverage).nil?
+    end
+
+    # Render the shared ladder in every terminal view.
+    def coverage_ladder_lines
+      return [] unless coverage_available?
+
+      aggregate = value(@analysis, :coverage) || {}
+      rows = [["D", :decision, :covered_decisions, :supported_decisions],
+              ["C", :condition, :covered_values, :required_values],
+              ["C/D", :condition_decision, :covered_decisions, :supported_decisions],
+              ["MC/DC", :mcdc, :proven_conditions, :supported_conditions]]
+      lines = ["Coverage ladder:"]
+      rows.each do |label, key, numerator_key, denominator_key|
+        row = value(aggregate, key)
+        next unless row
+
+        percentage = value(row, :percentage)
+        numerator = value(row, numerator_key) || 0
+        denominator = value(row, denominator_key) || 0
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        denominator_label = if ["D", "C/D"].include?(label)
+                              "decisions"
+                            else
+                              label == "C" ? "truth values" : "conditions"
+                            end
+        qualifier = incomplete? ? " (lower bound)" : ""
+        description = case label
+                      when "D" then "Decision coverage"
+                      when "C" then "Condition coverage"
+                      when "C/D" then "Condition/decision coverage"
+                      else "MC/DC coverage"
+                      end
+        lines << "  #{label} (#{description}): #{shown} (#{numerator}/#{denominator} #{denominator_label})#{qualifier}"
+      end
+      alternative = value(aggregate, :alternative)
+      if alternative
+        covered = value(alternative, :covered_alternatives) || 0
+        required = value(alternative, :required_alternatives) || 0
+        percentage = value(alternative, :percentage)
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        lines << "  Alternative coverage: #{covered}/#{required} alternatives (#{shown})"
+      end
+      lines << ""
+      lines
+    end
+
+    def criterion_status_text(label, row)
+      raw_status = value(row, :status).to_s.downcase
+      status = coverage_status_label(raw_status)
+      return "#{label}=#{status}" if raw_status == "unsupported"
+
+      case label
+      when "D"
+        "#{label}=#{status} (#{value(row, :covered_outcomes) || 0}/#{value(row, :required_outcomes) || 0} outcomes)"
+      when "C"
+        "#{label}=#{status} (#{value(row, :covered_values) || 0}/#{value(row, :required_values) || 0} values; " \
+        "#{value(row, :covered_conditions) || 0}/#{value(row, :condition_count) || 0} conditions fully covered)"
+      when "MC/DC"
+        "#{label}=#{status} (#{value(row, :proven_conditions) || 0}/#{value(row, :condition_count) || 0} conditions)"
+      else
+        "#{label}=#{status}"
+      end
     end
 
     def analysis_complete?
@@ -538,11 +834,29 @@ module Branchproof
     def missing_summary_line
       return "Missing conditions: Cannot identify missing conditions (analysis unavailable)" unless analysis_available?
       return "Missing conditions: Cannot identify missing conditions (analysis incomplete)" unless analysis_complete?
-      return "No eligible conditions" if metrics[:eligible_conditions].zero?
-      return "No missing conditions" if analysis_complete? && missing_condition_count.zero?
+      return "No missing conditions or alternatives" if analysis_complete? && missing_condition_count.zero? &&
+                                                        missing_alternatives_count.zero?
+      return "No eligible conditions" if metrics[:eligible_conditions].zero? && metrics[:eligible_alternatives].zero?
 
       count = decisions_to_render.length
-      "Missing conditions: #{missing_condition_count} across #{count} #{count == 1 ? "decision" : "decisions"}"
+      if missing_alternatives_count.zero?
+        label = count == 1 ? "decision" : "decisions"
+        return "Missing conditions: #{missing_condition_count} across #{count} #{label}"
+      end
+      if missing_condition_count.zero?
+        label = count == 1 ? "decision" : "decisions"
+        return "Missing alternatives: #{missing_alternatives_count} across #{count} #{label}"
+      end
+
+      label = count == 1 ? "decision" : "decisions"
+      conditions = missing_condition_count
+      alternatives = missing_alternatives_count
+      "Missing conditions: #{conditions}; alternatives: #{alternatives} " \
+        "across #{count} #{label}"
+    end
+
+    def missing_alternatives_count
+      decisions_to_render.sum { |decision| missing_alternatives_for(decision).length }
     end
 
     def analysis_for(decision)
@@ -604,5 +918,8 @@ module Branchproof
     def normalize_unknown(object)
       object.to_s
     end
+    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label
   end
 end
+
+# rubocop:enable Metrics/BlockLength

data/lib/branchproof/runtime.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require "securerandom"
+require_relative "runtime_flow"
 
 module Branchproof
   # Process-local execution recorder. It deliberately never coerces or stores
   # application values: Ruby's conditional expression is used for truthiness.
   # Captures condition evaluations while preserving application values.
   module Runtime
+    extend RuntimeFlow
+
     class << self
       def boot(evidence:)
         return nil if defined?(@booted) && @booted && @evidence.equal?(evidence) && Process.pid == @process_id

data/lib/branchproof/runtime_flow.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Records native Ruby path selection without evaluating application values twice.
+  module RuntimeFlow
+    def flow_candidate(decision_id, index)
+      frame = current_frame(decision_id)
+      frame[:observations] << [index, false] if frame
+      nil
+    end
+
+    def flow_selected(decision_id)
+      frame = current_frame(decision_id)
+      if frame && !frame[:observations].empty?
+        frame[:observations].last[1] = true
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_select(decision_id, index)
+      frame = current_frame(decision_id)
+      if frame
+        frame[:observations] = (0..index).map { |position| [position, position == index] }
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_path(decision_id, index)
+      frame = current_frame(decision_id)
+      if frame
+        frame[:observations] = [[0, index.zero?], [1, index == 1]]
+        frame[:outcome] = true
+        frame[:finished] = true
+      end
+      nil
+    end
+
+    def flow_finish(decision_id, value, default_path = nil)
+      frame = current_frame(decision_id)
+      flow_path(decision_id, default_path) if frame && !frame[:finished] && !default_path.nil?
+      value
+    end
+
+    def flow_receiver(decision_id, receiver)
+      enter(decision_id)
+      begin
+        flow_path(decision_id, nil.equal?(receiver) ? 0 : 1)
+      ensure
+        leave(decision_id)
+      end
+      receiver
+    end
+  end
+end