branchproof 0.11.1 → 0.12.0

data/lib/branchproof/comparison.rb

@@ -8,7 +8,7 @@ module Branchproof
   # Compares two complete report documents without loading or executing the project.
   class Comparison
     SCHEMA_VERSION = "1.0"
-    SUPPORTED_REPORT_SCHEMAS = %w[1.0 1.1 1.2 1.3 1.4].freeze
+    SUPPORTED_REPORT_SCHEMAS = %w[1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7].freeze
     CRITERION_VERSION = "masking_occurrence_v1"
 
     def initialize(before:, after:)
@@ -58,7 +58,7 @@ module Branchproof
       status = reasons.empty? ? "complete" : "comparison incomplete"
       lost = changes.count { |change| change["change"] == "lost proof" }
 
-      {
+      result = {
         "schema_version" => SCHEMA_VERSION,
         "criterion_version" => CRITERION_VERSION,
         "status" => status,
@@ -87,8 +87,16 @@ module Branchproof
         "decision_table_regressions" => table_changes.count { |change| change["change"] == "rule coverage lost" },
         "regressions" => lost,
         "regression" => (lost.positive? || table_changes.any? { |change| change["change"] == "rule coverage lost" }) &&
-          status == "complete"
+                        status == "complete"
       }
+      if value(@before, :changed_scope) || value(@after, :changed_scope)
+        result["changed_scope"] = {
+          "before" => value(@before, :changed_scope),
+          "after" => value(@after, :changed_scope),
+          "notice" => "Changed scope is informational; comparison uses whole-run evidence."
+        }
+      end
+      result
     end
 
     private

data/lib/branchproof/comparison_report.rb

@@ -34,6 +34,8 @@ module Branchproof
 
     def terminal_document
       lines = ["Branchproof comparison", "Status: #{status}"]
+      changed_scope = value(:changed_scope)
+      lines << value_from(changed_scope, :notice).to_s if changed_scope
       reasons.each { |reason| lines << "Reason: #{reason}" }
       Array(value(:context)).each { |item| lines << "Context: #{item}" }
       lines << "Conditions: #{matching.fetch("matched_conditions",

data/lib/branchproof/configuration.rb

@@ -10,7 +10,7 @@ module Branchproof
     PROJECTS = %w[auto ruby rails].freeze
     FRAMEWORKS = %w[auto minitest rspec].freeze
     MINIMUM_CRITERIA = CoveragePolicy::CRITERIA.keys.freeze
-    FIELDS = %w[schema_version project framework sources tests exclude minimum].freeze
+    FIELDS = %w[schema_version project framework sources tests exclude minimum minimum_changed].freeze
 
     class << self
       def load(path:, root:, explicit: false, disabled: false)
@@ -52,7 +52,7 @@ module Branchproof
         payload.each_with_object({ schema_version: SCHEMA_VERSION, path: path, root: root }) do |(key, value), result|
           next if key == "schema_version"
 
-          result[key.to_sym] = key == "minimum" ? value.transform_keys(&:to_s) : value
+          result[key.to_sym] = %w[minimum minimum_changed].include?(key) ? value.transform_keys(&:to_s) : value
         end
       end
 
@@ -77,6 +77,7 @@ module Branchproof
         %w[sources tests].each { |field| validate_nonempty_strings(payload, field) if payload.key?(field) }
         validate_strings(payload, "exclude") if payload.key?("exclude")
         validate_minimum(payload["minimum"]) if payload.key?("minimum")
+        validate_minimum_changed(payload["minimum_changed"]) if payload.key?("minimum_changed")
       end
 
       def validate_enum(payload, field, values)
@@ -106,6 +107,15 @@ module Branchproof
       rescue ArgumentError => e
         raise ArgumentError, "configuration minimum #{e.message.sub(/\Acoverage minimum for /, "")}"
       end
+
+      def validate_minimum_changed(value)
+        raise ArgumentError, "configuration minimum_changed must be an object" unless value.is_a?(Hash)
+
+        CoveragePolicy.normalize(value)
+      rescue ArgumentError => e
+        message = e.message.sub(/\Acoverage minimum for /, "")
+        raise ArgumentError, "configuration minimum_changed #{message}"
+      end
     end
   end
 end

data/lib/branchproof/coverage_policy.rb

@@ -2,6 +2,8 @@
 
 # rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists
 
+require_relative "changed_coverage"
+
 module Branchproof
   # Evaluates configured coverage thresholds against the aggregate Analyzer
   # coverage counts without relying on rounded percentage fields.
@@ -164,6 +166,126 @@ module Branchproof
       hash.key?(key) || hash.key?(key.to_s) || hash.key?(key.to_sym)
     end
   end
+
+  # Evaluates gates against the captured changed-scope summary independently
+  # from whole-run coverage policy.
+  class ChangedCoveragePolicy
+    CRITERIA = CoveragePolicy::CRITERIA
+    COMPLETENESS_FIELDS = CoveragePolicy::COMPLETENESS_FIELDS
+
+    def initialize(minimum_changed:)
+      raise ArgumentError, "minimum_changed must be a hash" unless minimum_changed.is_a?(Hash)
+
+      @minimum_changed = CoveragePolicy.normalize(minimum_changed)
+    end
+
+    def call(document:, scope:)
+      return { minimum_changed: @minimum_changed.dup, status: "passed", gates: [] } if @minimum_changed.empty?
+
+      global_reason = availability_reason(document)
+      empty_scope = value(scope, :status) == "empty" && Array(value(scope, :decision_ids)).empty?
+      changed_coverage = ChangedCoverage.call(document: document, scope: scope)
+      gates = @minimum_changed.map do |criterion, threshold|
+        if global_reason
+          gate(criterion, threshold, nil, nil, "unavailable", global_reason)
+        elsif empty_scope
+          gate(criterion, threshold, 0, 0, "not_applicable", "empty_scope")
+        else
+          evaluate_gate(criterion, threshold, changed_coverage)
+        end
+      end
+      status = if gates.all? { |item| item[:status] == "not_applicable" }
+                 "not_applicable"
+               elsif gates.any? { |item| item[:status] == "unavailable" }
+                 "unavailable"
+               elsif gates.any? { |item| item[:status] == "failed" }
+                 "failed"
+               else
+                 "passed"
+               end
+      { minimum_changed: @minimum_changed.dup, status: status, gates: gates }
+    end
+
+    private
+
+    def evaluate_gate(criterion, threshold, summary)
+      unless summary.is_a?(Hash) && value(summary, :status) == "available"
+        return gate(criterion, threshold, nil, nil, "unavailable",
+                    value(summary, :reason) || "changed_coverage_unavailable")
+      end
+
+      row = value(value(summary, :coverage), criterion)
+      return gate(criterion, threshold, nil, nil, "unavailable", "missing_coverage_count") unless row.is_a?(Hash)
+
+      numerator = value(row, :numerator)
+      denominator = value(row, :denominator)
+      reason = value(row, :reason)
+      status = value(row, :status).to_s
+      unless status == "available"
+        return gate(criterion, threshold, numerator, denominator, "unavailable",
+                    reason || "changed_coverage_unavailable")
+      end
+      unless valid_count?(numerator) && valid_count?(denominator)
+        return gate(criterion, threshold, numerator, denominator, "unavailable", "invalid_coverage_count")
+      end
+      return gate(criterion, threshold, numerator, denominator, "unavailable", "zero_denominator") if denominator.zero?
+      if numerator > denominator
+        return gate(criterion, threshold, numerator, denominator, "unavailable", "invalid_coverage_count")
+      end
+
+      result = numerator * 100 >= denominator * Rational(threshold.to_s) ? "passed" : "failed"
+      gate(criterion, threshold, numerator, denominator, result, nil)
+    end
+
+    def availability_reason(document)
+      return "document_unavailable" unless document.is_a?(Hash)
+
+      baseline = value(document, :baseline)
+      passed = baseline.is_a?(Hash) && value(baseline, :status).to_s.upcase == "PASSED"
+      return "baseline_unavailable" unless passed && value(baseline, :finalized) == true
+
+      completeness = value(document, :completeness)
+      return "incomplete_document" unless complete?(completeness)
+
+      observations = value(document, :observations) || value(document, :evidence)
+      return "incomplete_observations" unless observations.is_a?(Hash) && complete?(value(observations, :completeness))
+
+      analysis = value(document, :analysis)
+      return "incomplete_analysis" unless analysis.is_a?(Hash)
+      return "incomplete_analysis" unless complete?(value(analysis, :completeness))
+
+      nil
+    end
+
+    def complete?(completeness)
+      completeness.is_a?(Hash) && COMPLETENESS_FIELDS.all? { |field| value(completeness, field) == true }
+    end
+
+    def incomplete_section?(section)
+      section.is_a?(Hash) && key_present?(section, :completeness) && !complete?(value(section, :completeness))
+    end
+
+    def valid_count?(count)
+      count.is_a?(Integer) && count >= 0
+    end
+
+    def gate(criterion, threshold, numerator, denominator, status, reason)
+      { criterion: criterion, numerator: numerator, denominator: denominator, minimum: threshold,
+        status: status, reason: reason }
+    end
+
+    def value(hash, key)
+      return nil unless hash.respond_to?(:key?)
+      return hash[key] if hash.key?(key)
+
+      alternate = key.is_a?(Symbol) ? key.to_s : key.to_sym
+      hash[alternate] if hash.key?(alternate)
+    end
+
+    def key_present?(hash, key)
+      hash.key?(key) || hash.key?(key.to_s) || hash.key?(key.to_sym)
+    end
+  end
 end
 
 # rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists

data/lib/branchproof/coverage_summary.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "decision_table"
+
+# rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+module Branchproof
+  # Totals per-decision analyzer coverage without changing its counting rules.
+  module CoverageSummary
+    module_function
+
+    def call(decisions)
+      supported = decisions.reject { |decision| value(decision, :unsupported) }
+      boolean_supported = supported.reject { |decision| alternative_decision?(decision) }
+      decision_covered = boolean_supported.count do |decision|
+        value(value(decision, :coverage), :decision)&.then { value(_1, :status) } == "covered"
+      end
+      condition_decision_covered = boolean_supported.count do |decision|
+        value(value(decision, :coverage), :condition_decision)&.then { value(_1, :status) } == "covered"
+      end
+      condition_count = boolean_supported.sum do |decision|
+        value(value(decision, :coverage), :condition)&.then { value(_1, :condition_count) }.to_i
+      end
+      condition_values = boolean_supported.sum do |decision|
+        value(value(decision, :coverage), :condition)&.then { value(_1, :covered_values) }.to_i
+      end
+      covered_conditions = boolean_supported.sum do |decision|
+        value(value(decision, :coverage), :condition)&.then { value(_1, :covered_conditions) }.to_i
+      end
+      proven = boolean_supported.sum do |decision|
+        value(value(decision, :coverage), :mcdc)&.then { value(_1, :proven_conditions) }.to_i
+      end
+      {
+        decision: { covered_decisions: decision_covered, supported_decisions: boolean_supported.length,
+                    percentage: DecisionTable.percentage(decision_covered, boolean_supported.length) },
+        condition: { covered_values: condition_values, required_values: condition_count * 2,
+                     covered_conditions: covered_conditions, condition_count: condition_count,
+                     percentage: DecisionTable.percentage(condition_values, condition_count * 2) },
+        condition_decision: { covered_decisions: condition_decision_covered,
+                              supported_decisions: boolean_supported.length,
+                              percentage: DecisionTable.percentage(condition_decision_covered,
+                                                                   boolean_supported.length) },
+        mcdc: { proven_conditions: proven, supported_conditions: condition_count,
+                percentage: DecisionTable.percentage(proven, condition_count) },
+        decision_table: decision_table_aggregate(boolean_supported),
+        alternative: alternative_aggregate(decisions)
+      }
+    end
+
+    def decision_table_aggregate(boolean_supported)
+      analyzed = boolean_supported.select do |decision|
+        value(value(decision, :decision_table), :status) == "calculated"
+      end
+      not_calculated = boolean_supported.length - analyzed.length
+      covered = analyzed.sum { |decision| value(value(decision, :decision_table), :covered_rules).to_i }
+      required = analyzed.sum { |decision| value(value(decision, :decision_table), :required_rules).to_i }
+      generated = analyzed.sum { |decision| value(value(decision, :decision_table), :generated_rules).to_i }
+      impossible = analyzed.sum { |decision| value(value(decision, :decision_table), :impossible_rules).to_i }
+      fully_covered = analyzed.count do |decision|
+        value(value(decision, :decision_table), :coverage_status) == "covered"
+      end
+      { decisions_analyzed: analyzed.length, not_calculated_decisions: not_calculated,
+        fully_covered_decisions: fully_covered, covered_rules: covered, required_rules: required,
+        generated_rules: generated, impossible_rules: impossible,
+        percentage: DecisionTable.percentage(covered, required),
+        decision_percentage: DecisionTable.percentage(fully_covered, analyzed.length) }
+    end
+
+    def alternative_aggregate(decisions)
+      flow = decisions.select { |decision| !value(decision, :unsupported) && alternative_decision?(decision) }
+      required = flow.sum do |decision|
+        value(value(value(decision, :coverage), :alternative), :required_alternatives).to_i
+      end
+      covered = flow.sum do |decision|
+        value(value(value(decision, :coverage), :alternative), :covered_alternatives).to_i
+      end
+      { covered_alternatives: covered, required_alternatives: required,
+        supported_decisions: flow.length, percentage: DecisionTable.percentage(covered, required) }
+    end
+
+    def alternative_decision?(decision)
+      kind = value(decision, :kind).to_s
+      !kind.empty? && kind != "boolean"
+    end
+
+    def value(hash, key)
+      return nil unless hash.respond_to?(:key?)
+      return hash[key] if hash.key?(key)
+
+      alternate = key.is_a?(Symbol) ? key.to_s : key.to_sym
+      hash[alternate] if hash.key?(alternate)
+    end
+    private_class_method :value
+  end
+end

data/lib/branchproof/doctor.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "rubygems"
+
+module Branchproof
+  # Checks static setup facts without loading a project's tests or source files.
+  # rubocop:disable-next Metrics/ClassLength -- This service owns one small, cohesive static diagnostic document.
+  class Doctor
+    LIMITATIONS = [
+      "Static checks only: application boot, framework test discovery, runner compatibility, source syntax and " \
+      "instrumentation, and coverage are not verified.",
+      "A discovered test file may contain no executable tests; runtime loader conflicts and application behavior " \
+      "remain unverified."
+    ].freeze
+    FRAMEWORK_GEMS = {
+      "minitest" => { name: "minitest", requirement: Gem::Requirement.new(">= 5.25.5", "< 7") },
+      "rspec" => { name: "rspec-core", requirement: Gem::Requirement.new("~> 3.13.0") }
+    }.freeze
+
+    def initialize(options:, runtime: { engine: RUBY_ENGINE, version: RUBY_VERSION },
+                   loaded_features: $LOADED_FEATURES,
+                   gem_sources: { activated: Gem.loaded_specs,
+                                  discoverable: ->(name) { Gem::Specification.find_all_by_name(name) } })
+      @options = options
+      @runtime_engine = runtime.fetch(:engine).to_s
+      @runtime_version = runtime.fetch(:version).to_s
+      @loaded_features = loaded_features
+      @loaded_specs = gem_sources.fetch(:activated)
+      @visible_specs = gem_sources.fetch(:discoverable)
+    end
+
+    def document(source_files:, test_files:)
+      framework = framework_info(@options[:project][:framework])
+      checks = build_checks(framework, source_files, test_files)
+      result_document(framework: framework, checks: checks, source_files: source_files, test_files: test_files)
+    end
+
+    def self.error(message)
+      ERROR_DOCUMENT.merge(runtime: { engine: RUBY_ENGINE, version: RUBY_VERSION },
+                           checks: [{ code: "setup", status: "error", message: message.to_s }])
+    end
+
+    def self.terminal(document) = TerminalRenderer.new(document).render
+
+    ERROR_DOCUMENT = {
+      schema_version: 1, command: "doctor", status: "blocked", project: nil, configuration: nil,
+      selection: nil, framework: nil, limitations: LIMITATIONS
+    }.freeze
+
+    private
+
+    def build_checks(framework, source_files, test_files)
+      checks = [runtime_check, framework_check(framework), selection_check("sources", source_files),
+                selection_check("tests", test_files)]
+      loaded_runtime_warning(checks)
+      checks
+    end
+
+    def result_document(framework:, checks:, source_files:, test_files:)
+      status = checks.any? { |check| check[:status] == "error" } ? "blocked" : "ready"
+      {
+        schema_version: 1, command: "doctor", status: status,
+        runtime: { engine: @runtime_engine, version: @runtime_version }, project: @options[:project],
+        configuration: configuration_info(@options[:configuration], @options),
+        selection: selection_info(source_files, test_files), framework: framework,
+        checks: checks, limitations: LIMITATIONS
+      }
+    end
+
+    def runtime_check
+      supported = @runtime_engine == "ruby" && Gem::Version.new(@runtime_version) >= Gem::Version.new("4.0")
+      message = "CRuby >= 4.0 required; found #{@runtime_engine} #{@runtime_version}"
+      check("runtime", supported ? "pass" : "error", message)
+    rescue ArgumentError
+      check("runtime", "error", "could not parse Ruby version #{@runtime_version.inspect}")
+    end
+
+    def framework_check(framework)
+      requirement = FRAMEWORK_GEMS.fetch(framework[:name])[:requirement]
+      version = framework[:version] && Gem::Version.new(framework[:version])
+      supported = version && requirement.satisfied_by?(version)
+      state = supported ? "pass" : "error"
+      check("framework", state, framework_message(framework, requirement, version, supported))
+    end
+
+    def framework_message(framework, requirement, version, supported)
+      if supported
+        "#{framework[:gem]} #{version} is #{framework[:availability]}; version metadata is supported"
+      elsif version
+        "#{framework[:gem]} #{version} is #{framework[:availability]}, outside supported range #{requirement}; " \
+          "add #{framework[:gem]} #{requirement} to the current test bundle"
+      else
+        "#{framework[:gem]} is not available; add #{framework[:gem]} #{requirement} to the current test bundle"
+      end
+    end
+
+    def selection_check(kind, files)
+      count = files.length
+      if count.positive?
+        check("#{kind}_selected", "pass", "#{count} #{kind.sub(/s\z/, "")} file(s) selected")
+      else
+        advice = selection_advice(kind)
+        check("#{kind}_selected", "error", "no #{kind.sub(/s\z/, "")} files selected; #{advice}")
+      end
+    end
+
+    def selection_advice(kind)
+      return "check source globs and excludes" if kind == "sources"
+
+      "check --test, configured tests, or project test patterns"
+    end
+
+    def loaded_runtime_warning(checks)
+      conflicts = loaded_runtime_conflicts
+      return if conflicts.empty?
+
+      checks << check("loaded_runtime", "warning",
+                      loaded_runtime_message(conflicts))
+    end
+
+    def loaded_runtime_message(conflicts)
+      "#{conflicts.join(" and ")} already loaded; loader conflicts are not exercised by this static check"
+    end
+
+    def loaded_runtime_conflicts
+      @loaded_features.filter_map do |feature|
+        path = feature.to_s
+        if path.match?(%r{(?:\A|/)spring(?:/|\.|\z)}i)
+          "Spring"
+        elsif path.match?(%r{(?:\A|/)bootsnap(?:/|\.|\z)}i)
+          "Bootsnap"
+        end
+      end.uniq
+    end
+
+    def framework_info(framework)
+      requirement = FRAMEWORK_GEMS.fetch(framework)
+      spec = @loaded_specs[requirement[:name]]
+      availability = "activated"
+      unless spec
+        spec = Array(@visible_specs.call(requirement[:name])).max_by(&:version)
+        availability = "discoverable" if spec
+      end
+      { name: framework, gem: requirement[:name], version: spec&.version&.to_s,
+        availability: spec ? availability : "missing", requirement: requirement[:requirement].to_s }
+    end
+
+    def configuration_info(config, options)
+      { state: configuration_state(config, options), path: configuration_path(config, options),
+        minimum: config ? config.fetch(:minimum, {}) : {},
+        minimum_changed: config ? config.fetch(:minimum_changed, {}) : {} }
+    end
+
+    def configuration_state(config, options)
+      return "disabled" if options[:config_disabled]
+      return "loaded" if config
+
+      "default absent"
+    end
+
+    def configuration_path(config, options)
+      return nil if options[:config_disabled]
+
+      config ? config[:path] : File.expand_path(".branchproof.json", options[:project][:root])
+    end
+
+    def selection_info(source_files, test_files)
+      {
+        source_patterns: @options[:source_patterns],
+        test_patterns: @options[:test_patterns],
+        excludes: @options[:exclude],
+        source_count: source_files.length,
+        test_count: test_files.length
+      }
+    end
+
+    def check(code, status, message)
+      { code: code, status: status, message: message }
+    end
+  end
+
+  # Checks static setup facts and renders diagnostics without executing project code.
+  class Doctor
+    # Formats the structured document as concise terminal output.
+    class TerminalRenderer
+      def initialize(document)
+        @document = document
+      end
+
+      def render
+        lines = header_lines
+        lines.concat(project_lines, configuration_lines, selection_lines, check_lines, limitation_lines)
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def header_lines
+        ["Branchproof doctor: #{@document[:status]}",
+         "Ruby: #{@document.dig(:runtime, :engine)} #{@document.dig(:runtime, :version)}"]
+      end
+
+      def project_lines
+        project = @document[:project]
+        return [] unless project
+
+        framework = @document[:framework]
+        ["Project: #{project[:kind]} (#{project[:root]})",
+         "Framework: #{framework[:name]} #{framework[:version] || "unavailable"} (#{framework[:availability]})"]
+      end
+
+      def configuration_lines
+        configuration = @document[:configuration]
+        return [] unless configuration
+
+        path = configuration[:path] ? " (#{configuration[:path]})" : nil
+        minimum = configuration[:minimum].empty? ? "none" : configuration[:minimum].inspect
+        changed = configuration[:minimum_changed].empty? ? "none" : configuration[:minimum_changed].inspect
+        ["Config: #{configuration[:state]}#{path}", "Configured minima: #{minimum} (not evaluated)",
+         "Configured changed minima: #{changed} (not evaluated)"]
+      end
+
+      def selection_lines
+        selection = @document[:selection]
+        return [] unless selection
+
+        ["Sources: #{selection[:source_count]} files from #{selection[:source_patterns].join(", ")}",
+         "Tests: #{selection[:test_count]} files from #{selection[:test_patterns].join(", ")}",
+         "Excludes: #{selection[:excludes].empty? ? "none" : selection[:excludes].join(", ")}"]
+      end
+
+      def check_lines
+        @document[:checks].map { |check| "#{check[:status].upcase}: #{check[:message]}" }
+      end
+
+      def limitation_lines
+        @document[:limitations].map { |limitation| "Static-only: #{limitation}" }
+      end
+    end
+  end
+end

data/lib/branchproof/evidence.rb

@@ -37,6 +37,7 @@ module Branchproof
       @repetition_cache = {}
       @limited = false
       @attribution_complete = true
+      @analysis_complete = true
     end
 
     def register_test(test:)
@@ -134,7 +135,7 @@ module Branchproof
                              tests: @tests.values, vectors: @vectors.values,
                              abort_counts: @abort_counts.dup, diagnostics: @diagnostics.map(&:dup),
                              completeness: { observation: !@limited, attribution: @attribution_complete,
-                                             analysis: true } }))
+                                             analysis: @analysis_complete } }))
     end
 
     def merge(snapshot:)
@@ -180,6 +181,7 @@ module Branchproof
       @abort_counts.merge!(incoming.fetch(:abort_counts, {})) { |_k, a, b| a.to_i + b.to_i }
       @limited ||= !incoming.dig(:completeness, :observation)
       @attribution_complete &&= incoming.dig(:completeness, :attribution) ? true : false
+      @analysis_complete &&= incoming.dig(:completeness, :analysis) ? true : false
       @repetition_cache.clear
       status("merged", nil)
     rescue StandardError => e
@@ -565,6 +567,7 @@ module Branchproof
       { vectors: deep_dup(@vectors), tests: deep_dup(@tests), run_ids: @run_ids.dup,
         run_payloads: @run_payloads.dup, diagnostics: deep_dup(@diagnostics),
         abort_counts: @abort_counts.dup, limited: @limited, attribution_complete: @attribution_complete,
+        analysis_complete: @analysis_complete,
         vector_counts_by_decision: @vector_counts_by_decision.dup, owner_associations_count: @owner_associations_count,
         repetition_cache: deep_dup(@repetition_cache) }
     end
@@ -581,6 +584,7 @@ module Branchproof
       @repetition_cache = state[:repetition_cache]
       @limited = state[:limited]
       @attribution_complete = state[:attribution_complete]
+      @analysis_complete = state[:analysis_complete]
     end
 
     def cached_execution(execution)

data/lib/branchproof/exception_instrumentation.rb

@@ -41,9 +41,10 @@ module Branchproof
           replacements << { start: transfer.fetch(:insert_at), length: 0,
                             text: "#{runtime}.exception_path(#{identifier}, 0); " }
         end
-      elsif metadata[:normal_body] && metadata[:normal_body][:byte_length].positive?
-        replacements << flow_replacement(bytes, metadata.fetch(:normal_body), nested, encloses) do |body|
-          "#{runtime}.exception_value(#{identifier}, (begin; #{body}; end), 0)"
+      elsif metadata[:normal_value] && metadata[:normal_value][:byte_length].positive?
+        local = metadata.fetch(:normal_value_local)
+        replacements << flow_replacement(bytes, metadata.fetch(:normal_value), nested, encloses) do |value|
+          "begin; #{local} = (#{value}); #{runtime}.exception_value(#{identifier}, #{local}, 0); end"
         end
       end
       metadata.fetch(:clauses).each do |clause|

data/lib/branchproof/exception_syntax.rb

@@ -53,7 +53,8 @@ module Branchproof
         type: "exception",
         range: byte_range(node.location),
         normal_insert_at: exception_normal_insert_at(node),
-        normal_body: node.statements && byte_range(node.statements.location),
+        normal_value: exception_normal_value(node.statements),
+        normal_value_local: exception_normal_value_local(node, bytes),
         normal_transfer: exception_transfer_metadata(node.statements),
         implicit: node.begin_keyword_loc.nil?,
         normal_empty: node.begin_keyword_loc.nil? && exception_body_empty?(node),
@@ -137,6 +138,19 @@ module Branchproof
       [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode].any? { |klass| node.is_a?(klass) }
     end
 
+    def exception_normal_value(statements)
+      value = Array(statements&.body).last
+      return unless value
+
+      byte_range(value.location)
+    end
+
+    def exception_normal_value_local(node, bytes)
+      name = "__branchproof_exception_value_#{node.location.start_offset}"
+      name += "_" while bytes.include?(name)
+      name
+    end
+
     def exception_body_empty?(node)
       node.statements.nil? || statements_empty?(node.statements)
     end

data/lib/branchproof/fallback_instrumentation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Wraps each fallback operand so the runtime sees the operand's own value.
+  # `||` still short-circuits, so later operands are never evaluated early.
+  module FallbackInstrumentation
+    private
+
+    def render_flow(bytes, decision, nested, encloses)
+      metadata = decision.fetch(:instrumentation)
+      return super unless metadata[:type] == "fallback"
+
+      identifier = decision[:id].inspect
+      implicit = decision[:kind] == "implicit"
+      replacements = metadata.fetch(:operands).each_with_index.map do |operand, index|
+        flow_replacement(bytes, operand, nested, encloses) do |expression|
+          "#{self.class::RUNTIME}.fallback_operand(#{identifier}, #{index}, #{implicit}, (#{expression}))"
+        end
+      end
+      # No default_path: fallback_chain? guarantees the last operand is a truthy
+      # literal, so the frame always finishes through fallback_operand above.
+      flow_frame(decision[:id], flow_fragments(bytes, decision, nested, replacements, encloses))
+    end
+  end
+end