branchproof 0.7.0 → 0.9.0

data/lib/branchproof/report.rb

@@ -8,14 +8,19 @@ require "pathname"
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
-    SCHEMA_VERSION = "1.2"
+    SCHEMA_VERSION = "1.3"
     CRITERION_VERSION = "masking_occurrence_v1"
+    VIEWS = %i[decisions conditions tests decision_tables].freeze
+    DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
+    DECISION_TABLE_STATUS_LABELS = { "covered" => "COVERED", "missing" => "MISSING",
+                                     "excluded" => "EXCLUDED" }.freeze
 
     def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3, missing_only: false,
                    view: :decisions, run_metadata: {}, saved_document: nil)
       raise ArgumentError, "level must be 1, 2, or 3" unless [1, 2, 3].include?(level.to_i)
-      raise ArgumentError, "view must be :decisions, :conditions, or :tests" unless %i[decisions conditions
-                                                                                       tests].include?(view.to_sym)
+      unless VIEWS.include?(view.to_sym)
+        raise ArgumentError, "view must be :decisions, :conditions, :tests, or :decision_tables"
+      end
 
       @inventory = inventory || {}
       @evidence = evidence || {}
@@ -32,8 +37,8 @@ module Branchproof
 
     def self.from_document(document:, level: nil, view: :decisions, missing_only: false)
       data = document || {}
-      new(inventory: data[:source_inventory] || data["source_inventory"] || data[:inventory] || data["inventory"],
-          evidence: data[:observations] || data["observations"] || data[:evidence] || data["evidence"],
+      new(inventory: data[:source_inventory] || data["source_inventory"],
+          evidence: data[:observations] || data["observations"],
           analysis: data[:analysis] || data["analysis"], minima: data[:minima] || data["minima"],
           baseline: data[:baseline] || data["baseline"], diagnostics: data[:diagnostics] || data["diagnostics"],
           level: level || (data[:analysis] || data["analysis"] ? 3 : 1), view: view, missing_only: missing_only,
@@ -131,7 +136,7 @@ module Branchproof
     def terminal_document
       unless @view == :decisions
         return FocusedReport.new(document: json_document, view: @view, level: @level,
-                                 missing_only: @missing_only).render
+                                 missing_only: @missing_only, coordinator: self).render
       end
 
       @terminal_ids = terminal_ids
@@ -183,6 +188,7 @@ module Branchproof
         end
       end
       render_decision_coverage(lines, decision) if coverage_available?
+      render_decision_table(lines, decision) if analysis_available? && !nonboolean_decision?(decision)
       vectors_to_render(decision).each do |vector|
         values = Array(value(vector, :values)).map do |item|
           if item.nil?
@@ -230,7 +236,7 @@ module Branchproof
       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|
+                  ["MC/DC", :mcdc], ["DT", :decision_table]].filter_map do |label, key|
         row = value(all_coverage, key)
         status = value(row, :status)
         status ? criterion_status_text(label, row) : nil
@@ -242,11 +248,11 @@ module Branchproof
       return unless @level >= 2
 
       Array(value(coverage, :outcomes)).each do |outcome|
-        value_label = value(outcome, :value) ? "true" : "false"
+        value_label = decision_outcome_label(decision, value(outcome, :value))
         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}"
+        lines << "  #{value_label}: #{value(outcome, :observed) ? "observed" : "missing"}; tests: #{evidence}"
       end
       missing = Array(value(coverage, :missing_outcomes))
       return if missing.empty?
@@ -256,6 +262,164 @@ module Branchproof
       end.join(", ")}"
     end
 
+    # Renders the reduced decision table, its runtime overlay, and the
+    # actionable detail for rules that no observation reached.
+    def render_decision_table(lines, decision)
+      table = decision_table_for(decision)
+      return unless table
+
+      unless value(table, :status).to_s == "calculated"
+        return if value(table, :reason).to_s == "unsupported_decision" && unsupported?(decision)
+
+        lines << "  Decision Table: NOT CALCULATED"
+        lines << "  Reason: #{value(table, :reason)}"
+        return
+      end
+
+      covered = value(table, :covered_rules).to_i
+      required = value(table, :required_rules).to_i
+      percentage = value(table, :percentage)
+      lines << "  Decision Table: #{covered}/#{required} rules covered" \
+               "#{" (#{percentage}%)" unless percentage.nil?}"
+      impossible = value(table, :impossible_rules).to_i
+      lines << "  Statically impossible rules excluded: #{impossible}" if impossible.positive?
+      lines << "  Reachability: not analyzed" unless value(table, :reachability_analyzed)
+      rules = decision_table_rules_to_render(table)
+      lines.concat(decision_table_rows(decision, rules))
+      return unless @level >= 2
+
+      rules.each { |rule| render_decision_table_rule(lines, decision, rule) }
+    end
+
+    def decision_table_rows(decision, rules)
+      return [] if rules.empty?
+
+      conditions = Array(value(decision, :conditions))
+      header = ["Rule"] + conditions.map { |condition| truncate(value(condition, :expression).to_s, 24) } +
+               %w[Result Status]
+      body = rules.map do |rule|
+        [value(rule, :label).to_s] +
+          Array(value(rule, :conditions)).map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) } +
+          [value(rule, :outcome) ? "T" : "F", decision_table_rule_status(rule)]
+      end
+      return [] unless body.all? { |row| row.length == header.length }
+
+      widths = ([header] + body).transpose.map { |column| column.map(&:length).max }
+      ([header] + body).map do |row|
+        "    #{row.each_with_index.map { |cell, index| cell.ljust(widths[index]) }.join("  ").rstrip}"
+      end
+    end
+
+    def decision_table_rule_status(rule)
+      DECISION_TABLE_STATUS_LABELS.fetch(value(rule, :coverage).to_s, value(rule, :coverage).to_s.upcase)
+    end
+
+    def render_decision_table_rule(lines, decision, rule)
+      case value(rule, :coverage).to_s
+      when "covered" then render_covered_rule(lines, rule)
+      when "excluded" then lines.concat(impossible_rule_lines(rule))
+      else lines.concat(missing_rule_lines(decision, rule))
+      end
+    end
+
+    def render_covered_rule(lines, rule)
+      owners = Array(value(rule, :tests)).map { |id| test_label(id) }
+      owners << "unattributed" if value(rule, :unattributed_count).to_i.positive?
+      lines << "    #{value(rule, :label)} tests: #{owners.empty? ? "none recorded" : owners.uniq.join(", ")}"
+      return unless value(rule, :impossible_withdrawn)
+
+      lines << "    #{value(rule, :label)} note: runtime evidence overrides the static impossibility claim " \
+               "(#{value(rule, :withdrawn_reason)}); diagnostic constraint_model_conflict"
+    end
+
+    # Impossible rules stay visible even though they leave the denominator.
+    def impossible_rule_lines(rule)
+      ["    #{value(rule, :label)} #{rule_signature(rule)}",
+       "    Status:", "      EXCLUDED",
+       "    Reachability:", "      STATICALLY IMPOSSIBLE",
+       "    Reason:", "      #{Constraints.message(value(rule, :reachability_reason))}"]
+    end
+
+    # Condition values only: Branchproof never claims which application inputs
+    # would produce them.
+    def missing_rule_lines(decision, rule)
+      requirements = decision_table_requirements(decision, rule)
+      width = requirements.map { |name, _| name.length }.max.to_i
+      lines = ["    #{value(rule, :label)}", "    Need:"]
+      requirements.each { |name, requirement| lines << "      #{name.ljust(width)} #{requirement}" }
+      lines << "    #{decision_table_expected_heading(decision)}"
+      lines << "      #{value(rule, :outcome) ? "true" : "false"}"
+      lines << "    Reachability:"
+      lines << "      #{decision_table_reachability(rule)}"
+      lines
+    end
+
+    def decision_table_requirements(decision, rule)
+      Array(value(rule, :conditions)).each_with_index.map do |required, index|
+        expression = condition_expression(decision, index) || "condition #{index}"
+        requirement = decision_table_requirement(required) || "not evaluated (short-circuited)"
+        [expression.to_s, "= #{requirement}"]
+      end
+    end
+
+    def decision_table_requirement(value)
+      case value.to_s
+      when "true" then "truthy"
+      when "false" then "falsey"
+      end
+    end
+
+    def decision_table_reachability(rule)
+      return "STATICALLY IMPOSSIBLE" if value(rule, :reachability).to_s == "statically_impossible"
+
+      value(rule, :reachability).to_s
+    end
+
+    def decision_outcome_label(decision, outcome)
+      prefix = %w[unless until].include?(value(decision, :context).to_s) ? "Predicate" : "Outcome"
+      "#{prefix} #{outcome ? "true" : "false"}"
+    end
+
+    def decision_table_expected_heading(decision)
+      %w[unless until].include?(value(decision, :context).to_s) ? "Expected predicate:" : "Expected decision:"
+    end
+
+    def rule_signature(rule)
+      values = Array(value(rule, :conditions)).map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) }
+      "#{values.join} => #{value(rule, :outcome) ? "T" : "F"}"
+    end
+
+    def decision_table_rules_to_render(table)
+      rules = Array(value(table, :rules))
+      return rules unless @missing_only
+
+      rules.select { |rule| value(rule, :coverage).to_s == "missing" }
+    end
+
+    def decision_table_for(decision)
+      value(analysis_for(decision), :decision_table)
+    end
+
+    def missing_decision_table_rules(decision)
+      table = decision_table_for(decision)
+      return [] unless table && value(table, :status).to_s == "calculated"
+
+      Array(value(table, :rules)).select { |rule| value(rule, :coverage).to_s == "missing" }
+    end
+
+    def decision_table_unavailable?(decision)
+      table = decision_table_for(decision)
+      table && value(table, :status).to_s != "calculated"
+    end
+
+    def unavailable_decision_table_count
+      inventory_decisions.count { |decision| decision_table_unavailable?(decision) }
+    end
+
+    def truncate(text, width)
+      text.length <= width ? text : "#{text[0, width - 3]}..."
+    end
+
     def render_alternative_coverage(lines, decision)
       coverage = value(value(analysis_for(decision), :coverage), :alternative) || {}
       status = value(coverage, :status)
@@ -492,8 +656,15 @@ module Branchproof
     end
 
     def condition_result(decision, condition)
-      Array(value(analysis_for(decision), :condition_results)).find do |item|
-        value(item, :condition_id).to_s == value(condition, :id).to_s
+      condition_results_index.dig(value(decision, :id).to_s, value(condition, :id).to_s)
+    end
+
+    def condition_results_index
+      @condition_results_index ||= Array(value(@analysis, :decisions)).each_with_object({}) do |item, index|
+        by_condition_id = index[value(item, :decision_id).to_s] ||= {}
+        Array(value(item, :condition_results)).each do |result|
+          by_condition_id[value(result, :condition_id).to_s] = result
+        end
       end
     end
 
@@ -592,7 +763,11 @@ module Branchproof
       id = value(constraint, :existing_vector_id).to_s
       return if id.empty?
 
-      vectors.find { |vector| value(vector, :id).to_s == id }
+      vectors_by_id[id]
+    end
+
+    def vectors_by_id
+      @vectors_by_id ||= vectors.to_h { |vector| [value(vector, :id).to_s, vector] }
     end
 
     def values_legend
@@ -639,37 +814,41 @@ module Branchproof
     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), kind_counts: kind_counts,
-        decision_kinds: kind_counts, context_counts: context_counts }
+      @metrics ||= begin
+        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), kind_counts: kind_counts,
+          decision_kinds: kind_counts, context_counts: context_counts }
+      end
     end
 
     def completeness
-      evidence = value(@evidence, :completeness) || {}
-      analysis = value(@analysis, :completeness) || {}
-      { observation: completeness_value?(evidence, analysis, :observation),
-        attribution: completeness_value?(evidence, analysis, :attribution),
-        analysis: @analysis ? value(analysis, :analysis) == true : value(evidence, :analysis) == true }
+      @completeness ||= begin
+        evidence = value(@evidence, :completeness) || {}
+        analysis = value(@analysis, :completeness) || {}
+        { observation: completeness_value?(evidence, analysis, :observation),
+          attribution: completeness_value?(evidence, analysis, :attribution),
+          analysis: @analysis ? value(analysis, :analysis) == true : value(evidence, :analysis) == true }
+      end
     end
 
     def completeness_value?(evidence, analysis, key)
@@ -708,9 +887,11 @@ module Branchproof
     end
 
     def vectors_for(decision)
-      vectors.select do |vector|
-        value(vector, :decision_id).to_s == value(decision, :id).to_s
-      end
+      vectors_by_decision_id[value(decision, :id).to_s] || []
+    end
+
+    def vectors_by_decision_id
+      @vectors_by_decision_id ||= vectors.group_by { |vector| value(vector, :decision_id).to_s }
     end
 
     def decisions_to_render
@@ -720,7 +901,12 @@ module Branchproof
       inventory_decisions
         .reject { |decision| unsupported?(decision) }
         .select do |decision|
-          nonboolean_decision?(decision) ? missing_alternatives_for(decision).any? : conditions_to_render(decision).any?
+          if nonboolean_decision?(decision)
+            missing_alternatives_for(decision).any?
+          else
+            conditions_to_render(decision).any? || missing_decision_table_rules(decision).any? ||
+              decision_table_unavailable?(decision)
+          end
         end
     end
 
@@ -748,7 +934,6 @@ module Branchproof
 
     def vectors_to_render(decision)
       return vectors_for(decision) unless @missing_only
-      return [] if nonboolean_decision?(decision)
 
       []
     end
@@ -793,6 +978,24 @@ module Branchproof
                       end
         lines << "  #{label} (#{description}): #{shown} (#{numerator}/#{denominator} #{denominator_label})#{qualifier}"
       end
+      table = value(aggregate, :decision_table)
+      if table
+        covered = value(table, :covered_rules) || 0
+        required = value(table, :required_rules) || 0
+        percentage = value(table, :percentage)
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        qualifier = incomplete? ? " (lower bound)" : ""
+        lines << "  DT (Decision table coverage): #{shown} (#{covered}/#{required} rules)#{qualifier}"
+        fully_covered = value(table, :fully_covered_decisions) || 0
+        analyzed = value(table, :decisions_analyzed) || 0
+        decision_percentage = value(table, :decision_percentage)
+        lines << "  Decision tables fully covered: #{fully_covered}/#{analyzed} decisions" \
+                 "#{" (#{decision_percentage}%)" unless decision_percentage.nil?}"
+        impossible = value(table, :impossible_rules).to_i
+        lines << "  Statically impossible rules excluded: #{impossible}" if impossible.positive?
+        not_calculated = value(table, :not_calculated_decisions).to_i
+        lines << "  Decision tables not calculated: #{not_calculated} decisions" if not_calculated.positive?
+      end
       alternative = value(aggregate, :alternative)
       if alternative
         covered = value(alternative, :covered_alternatives) || 0
@@ -818,6 +1021,10 @@ module Branchproof
         "#{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)"
+      when "DT"
+        return "#{label}=NOT CALCULATED (#{value(row, :reason)})" if raw_status == "not_calculated"
+
+        "#{label}=#{status} (#{value(row, :covered_rules) || 0}/#{value(row, :required_rules) || 0} rules)"
       else
         "#{label}=#{status}"
       end
@@ -834,25 +1041,36 @@ 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 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
-      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}"
+      unavailable = unavailable_decision_table_count
+      unavailable_suffix = if unavailable.positive?
+                             "; decision-table analysis unavailable for #{unavailable} " \
+                               "#{unavailable == 1 ? "decision" : "decisions"}"
+                           else
+                             ""
+                           end
+      if missing_condition_count.zero? && missing_alternatives_count.zero? && missing_rule_count.zero?
+        return "No missing conditions, alternatives, or decision-table rules#{unavailable_suffix}"
       end
 
+      count = decisions_to_render.length
       label = count == 1 ? "decision" : "decisions"
-      conditions = missing_condition_count
-      alternatives = missing_alternatives_count
-      "Missing conditions: #{conditions}; alternatives: #{alternatives} " \
-        "across #{count} #{label}"
+      suffix = missing_rule_count.positive? ? "; decision-table rules: #{missing_rule_count}" : ""
+      summary = if missing_condition_count.positive? && missing_alternatives_count.positive?
+                  "Missing conditions: #{missing_condition_count}; alternatives: #{missing_alternatives_count} " \
+                    "across #{count} #{label}#{suffix}"
+                elsif missing_condition_count.positive?
+                  "Missing conditions: #{missing_condition_count} across #{count} #{label}#{suffix}"
+                elsif missing_alternatives_count.positive?
+                  "Missing alternatives: #{missing_alternatives_count} across #{count} #{label}#{suffix}"
+                else
+                  "Missing decision-table rules: #{missing_rule_count} across #{count} #{label}"
+                end
+      "#{summary}#{unavailable_suffix}"
+    end
+
+    def missing_rule_count
+      decisions_to_render.sum { |decision| missing_decision_table_rules(decision).length }
     end
 
     def missing_alternatives_count
@@ -860,19 +1078,33 @@ module Branchproof
     end
 
     def analysis_for(decision)
-      Array(value(@analysis, :decisions)).find do |item|
-        value(item, :decision_id).to_s == value(decision, :id).to_s
+      analysis_by_decision_id[value(decision, :id).to_s]
+    end
+
+    def analysis_by_decision_id
+      @analysis_by_decision_id ||= Array(value(@analysis, :decisions)).to_h do |item|
+        [value(item, :decision_id).to_s, item]
       end
     end
 
     def source_for(decision)
-      Array(value(@inventory, :source_units)).find do |source|
-        value(source, :source_id).to_s == value(decision, :source_id).to_s
-      end || decision
+      source_by_source_id[value(decision, :source_id).to_s] || decision
+    end
+
+    def source_by_source_id
+      @source_by_source_id ||= Array(value(@inventory, :source_units)).to_h do |source|
+        [value(source, :source_id).to_s, source]
+      end
+    end
+
+    def inventory_decisions
+      @inventory_decisions ||= Array(value(@inventory, :decisions)).freeze
+    end
+
+    def vectors
+      @vectors ||= Array(value(@evidence, :vectors)).freeze
     end
 
-    def inventory_decisions = Array(value(@inventory, :decisions))
-    def vectors = Array(value(@evidence, :vectors))
     def unsupported?(decision) = value(decision, :support_status).to_s.upcase == "UNSUPPORTED"
 
     def discovered_conditions(decision)
@@ -918,7 +1150,8 @@ module Branchproof
     def normalize_unknown(object)
       object.to_s
     end
-    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label
+    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label,
+           :decision_table_requirement, :decision_table_reachability, :decision_table_expected_heading
   end
 end
 

data/lib/branchproof/runtime.rb

@@ -2,6 +2,11 @@
 
 require "securerandom"
 require_relative "runtime_flow"
+require_relative "extended_alternative_runtime"
+require_relative "exception_runtime"
+require_relative "default_runtime"
+require_relative "value_runtime"
+require_relative "iteration_runtime"
 
 module Branchproof
   # Process-local execution recorder. It deliberately never coerces or stores
@@ -9,6 +14,13 @@ module Branchproof
   # Captures condition evaluations while preserving application values.
   module Runtime
     extend RuntimeFlow
+    extend ExtendedAlternativeRuntime
+    extend ExceptionRuntime
+    extend DefaultRuntime
+    extend ValueRuntime
+    extend IterationRuntime
+
+    FRAME_STATE_KEY = :branchproof_runtime_frame_state
 
     class << self
       def boot(evidence:)
@@ -17,8 +29,6 @@ module Branchproof
         @evidence = evidence
         @run_id = evidence.respond_to?(:run_id) ? evidence.run_id.to_s : SecureRandom.hex(16)
         @process_id = Process.pid
-        @frames = {}
-        @contexts = {}
         @diagnostics = []
         @storage_disabled = false
         @booted = true
@@ -26,9 +36,8 @@ module Branchproof
       end
 
       def enter(decision_id)
-        state[:frames] << { decision_id: String(decision_id), context: state[:context]&.dup,
-                            observations: [], outcome: nil, finished: false,
-                            execution_id: SecureRandom.hex(12) }
+        state[:frames] << { decision_id: decision_id, context: state[:context]&.dup,
+                            observations: [], outcome: nil, finished: false }
         nil
       end
 
@@ -36,7 +45,7 @@ module Branchproof
         frame = current_frame(decision_id)
         if frame
           truth = value ? true : false
-          frame[:observations] << [Integer(index), truth]
+          frame[:observations] << [index, truth]
         end
         value
       end
@@ -51,9 +60,10 @@ module Branchproof
       end
 
       def leave(decision_id)
+        detect_fork
         frames = state[:frames]
         frame = frames.pop
-        unless frame && frame[:decision_id] == String(decision_id)
+        unless frame && frame[:decision_id] == decision_id
           latch("runtime_frame_mismatch", "decision frame stack is not balanced")
           cleanup_state
           return nil
@@ -62,12 +72,10 @@ module Branchproof
 
         execution = {
           run_id: @run_id,
-          execution_id: frame[:execution_id],
           decision_id: frame[:decision_id],
           test_id: frame[:context]&.fetch(:test_id, nil),
           phase: frame[:context]&.fetch(:phase, "unattributed") || "unattributed",
-          owner: owner_tuple,
-          observations: frame[:observations].map(&:dup),
+          observations: frame[:observations],
           outcome: frame[:finished] ? frame[:outcome] : nil,
           status: frame[:finished] ? "completed" : "aborted"
         }
@@ -120,38 +128,32 @@ module Branchproof
       private
 
       def state
-        @frames ||= {}
-        if @process_id && Process.pid != @process_id
-          @process_id = Process.pid
-          @run_id = SecureRandom.hex(16)
-          @frames = {}
-          @diagnostics = [{ code: "forked_process", severity: "error",
-                            message: "runtime process identity changed; evidence storage disabled",
-                            source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }]
-          @storage_disabled = true
-        end
-        key = [Process.pid, Thread.current, Fiber.current]
-        @frames[key] ||= { frames: [], context: nil }
+        Thread.current[FRAME_STATE_KEY] ||= { frames: [], context: nil }
       end
 
       def cleanup_state
-        key = [Process.pid, Thread.current, Fiber.current]
-        current = @frames[key]
-        @frames.delete(key) if current && current[:frames].empty? && current[:context].nil?
+        current = Thread.current[FRAME_STATE_KEY]
+        Thread.current[FRAME_STATE_KEY] = nil if current && current[:frames].empty? && current[:context].nil?
+      end
+
+      def detect_fork
+        return unless @process_id && Process.pid != @process_id
+
+        @process_id = Process.pid
+        @diagnostics = [{ code: "forked_process", severity: "error",
+                          message: "runtime process identity changed; evidence storage disabled",
+                          source_id: nil, decision_id: nil, execution_id: nil, test_id: nil, details: {} }]
+        @storage_disabled = true
       end
 
       def current_frame(decision_id)
         frame = state[:frames].last
-        return frame if frame && frame[:decision_id] == String(decision_id)
+        return frame if frame && frame[:decision_id] == decision_id
 
         latch("runtime_frame_mismatch", "no active frame for #{decision_id}") if frame
         nil
       end
 
-      def owner_tuple
-        { process_id: Process.pid, thread_id: Thread.current.object_id, fiber_id: Fiber.current.object_id }
-      end
-
       def safely_record(execution)
         result = @evidence.record(execution: execution)
         unless result.is_a?(Hash) && result[:status].to_s == "recorded"