branchproof 0.11.0 → 0.12.0

data/lib/branchproof/report.rb

@@ -6,22 +6,33 @@ require "json"
 require "pathname"
 require_relative "coverage_policy"
 require_relative "report_selection"
+require_relative "summary_report"
+require_relative "github_report"
+require_relative "html_report"
+require_relative "changed_coverage"
 
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
     SCHEMA_VERSION = "1.4"
+    CHANGED_SCOPE_SCHEMA_VERSION = "1.5"
+    CHANGED_POLICY_SCHEMA_VERSION = "1.6"
+    COLLATION_SCHEMA_VERSION = "1.7"
     CRITERION_VERSION = "masking_occurrence_v1"
-    VIEWS = %i[decisions conditions tests decision_tables].freeze
+    VIEWS = %i[decisions conditions tests decision_tables summary].freeze
+    FORMATS = %i[terminal json github html].freeze
     DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
     DECISION_TABLE_STATUS_LABELS = { "covered" => "COVERED", "missing" => "MISSING",
                                      "excluded" => "EXCLUDED" }.freeze
+    CRITERIA_LABELS = { decision: "Decision", condition: "Condition", condition_decision: "Condition/decision",
+                        mcdc: "MC/DC", decision_table: "Decision table", alternative: "Alternative" }.freeze
 
     def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3, missing_only: false,
-                   view: :decisions, run_metadata: {}, saved_document: nil, focus: nil, top: nil, minimum: nil)
+                   view: :decisions, run_metadata: {}, saved_document: nil, focus: nil, top: nil, minimum: nil,
+                   changed_scope: nil, minimum_changed: nil)
       raise ArgumentError, "level must be 1, 2, or 3" unless [1, 2, 3].include?(level.to_i)
       unless VIEWS.include?(view.to_sym)
-        raise ArgumentError, "view must be :decisions, :conditions, :tests, or :decision_tables"
+        raise ArgumentError, "view must be :decisions, :conditions, :tests, :decision_tables, or :summary"
       end
 
       @inventory = inventory || {}
@@ -35,37 +46,65 @@ module Branchproof
       @view = view.to_sym
       @run_metadata = run_metadata || {}
       @saved_document = saved_document
+      raise ArgumentError, "changed_scope must be a hash" if !changed_scope.nil? && !changed_scope.is_a?(Hash)
+
+      @changed_scope = changed_scope
       raise ArgumentError, "minimum must be a hash" if !minimum.nil? && !minimum.is_a?(Hash)
 
       @minimum_override = minimum.is_a?(Hash) && !minimum.empty? ? CoveragePolicy.normalize(minimum) : nil
       @minimum = effective_minimum
-      @selection = ReportSelection.new(focus: focus, top: top)
+      raise ArgumentError, "minimum_changed must be a hash" if !minimum_changed.nil? && !minimum_changed.is_a?(Hash)
+
+      @minimum_changed_override = normalize_minimum_changed(minimum_changed)
+      @minimum_changed = effective_minimum_changed
+      if !@minimum_changed.empty? && !@changed_scope
+        raise ArgumentError, "minimum-changed requires a captured changed scope"
+      end
+
+      @selection = ReportSelection.new(focus: focus, top: top,
+                                       decision_ids: value(@changed_scope, :decision_ids))
     end
 
     def self.from_document(document:, level: nil, view: :decisions, missing_only: false, focus: nil, top: nil,
-                           minimum: nil)
+                           minimum: nil, minimum_changed: nil)
       data = document || {}
+      captured_scope = data[:changed_scope] || data["changed_scope"]
       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,
           focus: focus, top: top,
-          run_metadata: data[:run_metadata] || data["run_metadata"], saved_document: data, minimum: minimum)
+          run_metadata: data[:run_metadata] || data["run_metadata"], saved_document: data, minimum: minimum,
+          minimum_changed: minimum_changed,
+          changed_scope: captured_scope)
     end
 
-    def write(io:, format:)
+    # path_prefix is only used by :github, to make annotation paths repository-relative.
+    def write(io:, format:, path_prefix: nil)
       format = format.to_sym
-      raise ArgumentError, "format must be :terminal or :json" unless %i[terminal json].include?(format)
-      raise ArgumentError, "focus and top filters are terminal-only" if format == :json && @selection.active?
-
-      io.write(format == :json ? JSON.generate(json_document) : terminal_document)
+      raise ArgumentError, "format must be :terminal, :json, :github, or :html" unless FORMATS.include?(format)
+      raise ArgumentError, "focus and top filters are terminal-only" if format == :json &&
+                                                                        (@selection.focus_active? || @selection.top)
+
+      io.write(case format
+               when :json then JSON.generate(json_document)
+               when :github then github_report.annotations(path_prefix: path_prefix)
+               when :html then HtmlReport.new(document: json_document, level: @level, coordinator: self,
+                                              missing_only: @missing_only, selection: @selection).render
+               else terminal_document
+               end)
       nil
     end
 
+    # Markdown job summary for GitHub Actions ($GITHUB_STEP_SUMMARY).
+    def step_summary
+      github_report.step_summary
+    end
+
     # Shares the existing missing-case wording with focused terminal views.
     def condition_explanation(decision_id:, condition_id:)
-      decision = inventory_decisions.find { |item| value(item, :id).to_s == decision_id.to_s }
+      decision = inventory_decisions_by_id[decision_id.to_s]
       return "" unless decision
 
       condition = Array(value(decision, :conditions)).find { |item| value(item, :id).to_s == condition_id.to_s }
@@ -90,7 +129,7 @@ module Branchproof
     # 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 }
+      decision = inventory_decisions_by_id[decision_id.to_s]
       condition = Array(value(decision, :conditions)).find do |item|
         value(item, :id).to_s == condition_id.to_s
       end
@@ -112,12 +151,108 @@ module Branchproof
       lines
     end
 
+    # Shared informational changed-scope header for all terminal and GitHub views.
+    def changed_scope_lines
+      return [] unless @changed_scope
+
+      files = value(@changed_scope, :files)
+      deleted_paths = Array(files).filter_map do |file|
+        scope_text(value(file, :path)) if value(file, :status).to_s == "D"
+      end
+      ref = scope_text(value(@changed_scope, :requested_ref))
+      base = scope_text(value(@changed_scope, :base_commit))
+      lines = ["Changed scope: #{ref} (resolved #{base})",
+               "Comparison: tracked worktree; untracked files excluded"]
+      unless deleted_paths.empty?
+        lines << "Deleted files: #{deleted_paths.join(", ")} (no current decisions to display)"
+      end
+      header = @minimum_changed.empty? ? "Changed coverage (informational):" : "Changed coverage:"
+      lines << header
+      coverage = value(json_document, :changed_coverage) || {}
+      overall_unavailable = value(coverage, :reason)
+      if overall_unavailable && overall_unavailable.to_s != "zero_denominator"
+        lines << "  Changed coverage unavailable: #{changed_coverage_reason(coverage)}"
+      end
+      CRITERIA_LABELS.each do |criterion, label|
+        row = value(value(coverage, :coverage), criterion) || {}
+        denominator = value(row, :denominator)
+        percentage = value(row, :percentage)
+        lines << if value(row, :status).to_s == "available"
+                   "  #{label}: #{value(row, :numerator)}/#{denominator} (#{percentage}%)"
+                 elsif value(row, :reason).to_s == "zero_denominator"
+                   "  #{label}: N/A (not applicable)"
+                 else
+                   "  #{label}: unavailable (#{changed_coverage_reason(row)})"
+                 end
+      end
+      lines.concat(changed_coverage_policy_lines)
+      lines
+    end
+
+    # Provenance summary for offline reports assembled from multiple shards.
+    def collation_lines
+      collation = value(@saved_document, :collation)
+      return [] unless collation.is_a?(Hash)
+
+      shards = Array(value(collation, :shards))
+      expected = value(collation, :expected_shards)
+      count = if expected.is_a?(Array)
+                "#{shards.length}/#{expected.length} expected"
+              else
+                "#{shards.length} (expected count unknown)"
+              end
+      missing = Array(value(collation, :missing_shards)).map { |id| scope_text(id) }
+      lines = ["Collation: #{scope_text(value(collation, :collection_status))}",
+               "Shards supplied: #{count}",
+               "Missing shards: #{missing.empty? ? "none" : missing.join(", ")}",
+               "Contributing shards:"]
+      shards.each do |shard|
+        id = scope_text(value(shard, :id))
+        paths = Array(value(shard, :paths)).map { |path| scope_text(path) }
+        lines << "  #{id}: #{paths.empty? ? "path unavailable" : paths.join(", ")}"
+      end
+      lines
+    end
+
+    def changed_coverage_policy_lines
+      policy = changed_coverage_policy
+      return [] if (value(policy, :minimum_changed) || {}).empty?
+
+      lines = ["Changed coverage policy: #{value(policy, :status).to_s.upcase}"]
+      Array(value(policy, :gates)).each do |gate|
+        numerator = value(gate, :numerator)
+        denominator = value(gate, :denominator)
+        count = denominator.nil? || denominator.zero? ? "N/A" : "#{numerator || "N/A"}/#{denominator}"
+        suffix = value(gate, :reason) ? "; reason: #{value(gate, :reason)}" : ""
+        lines << "  #{value(gate, :criterion)}: #{count}, threshold #{value(gate, :minimum)}, " \
+                 "#{value(gate, :status).to_s.upcase}#{suffix}"
+      end
+      lines
+    end
+
+    def changed_coverage_available?
+      return true unless @changed_scope
+
+      coverage = value(json_document, :changed_coverage)
+      return false unless value(coverage, :status).to_s == "available"
+
+      rows = value(coverage, :coverage) || {}
+      rows.values.all? do |row|
+        value(row, :status).to_s == "available" || value(row, :reason).to_s == "zero_denominator"
+      end
+    end
+
+    def display_scope_path(path)
+      @changed_scope ? scope_text(path) : path
+    end
+
     def exit_code
       return 2 unless usage_valid?
 
       policy_status = value(coverage_policy, :status).to_s
-      return 2 if policy_status == "unavailable"
-      return 1 if policy_status == "failed"
+      changed_policy_status = value(changed_coverage_policy, :status).to_s
+      return 2 if [policy_status, changed_policy_status].include?("unavailable")
+      return 1 if [policy_status, changed_policy_status].include?("failed")
 
       status = value(@baseline, :status).to_s.upcase
       return 2 if %w[ERROR INCOMPLETE].include?(status)
@@ -148,20 +283,51 @@ module Branchproof
       if @saved_document
         document = normalize(@saved_document)
         document["coverage_policy"] = normalize(coverage_policy) if @minimum_override
+        if @minimum_changed_override
+          document["schema_version"] = if document["schema_version"] == COLLATION_SCHEMA_VERSION
+                                         COLLATION_SCHEMA_VERSION
+                                       else
+                                         CHANGED_POLICY_SCHEMA_VERSION
+                                       end
+          document["changed_coverage_policy"] = normalize(changed_coverage_policy)
+        end
         return document
       end
 
-      normalize(schema_version: SCHEMA_VERSION,
-                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_with_default_kinds, baseline: @baseline, observations: @evidence,
-                analysis: @analysis, minima: @minima, metrics: metrics,
-                diagnostics: @diagnostics, completeness: completeness, coverage_policy: coverage_policy,
-                run_metadata: @run_metadata)
+      schema_version = if !@minimum_changed.empty?
+                         CHANGED_POLICY_SCHEMA_VERSION
+                       elsif @changed_scope
+                         CHANGED_SCOPE_SCHEMA_VERSION
+                       else
+                         SCHEMA_VERSION
+                       end
+      document = normalize(schema_version: schema_version,
+                           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_with_default_kinds, baseline: @baseline, observations: @evidence,
+                           analysis: @analysis, minima: @minima, metrics: metrics,
+                           diagnostics: @diagnostics, completeness: completeness, coverage_policy: coverage_policy,
+                           run_metadata: @run_metadata)
+      if @changed_scope
+        document["changed_scope"] = normalize(@changed_scope)
+        document["changed_coverage"] = normalize(ChangedCoverage.call(document: document,
+                                                                      scope: @changed_scope))
+        document["changed_coverage_policy"] = normalize(changed_coverage_policy) unless @minimum_changed.empty?
+      end
+      document
+    end
+
+    def github_report
+      @github_report ||= GithubReport.new(document: json_document, level: @level, coordinator: self,
+                                          selection: @selection)
     end
 
     def terminal_document
+      if @view == :summary
+        return SummaryReport.new(document: json_document, level: @level, coordinator: self,
+                                 missing_only: @missing_only, selection: @selection).render
+      end
       unless @view == :decisions
         return FocusedReport.new(document: json_document, view: @view, level: @level,
                                  missing_only: @missing_only, coordinator: self,
@@ -179,8 +345,12 @@ module Branchproof
                "Observations: #{metrics[:completed]} completed, #{metrics[:aborted]} aborted, " \
                "#{metrics[:unattributed]} unattributed",
                values_legend]
+      lines.insert(1, "Whole-run metrics:") if @changed_scope
+      lines << "Whole-run coverage and policy:" if @changed_scope
       lines.concat(coverage_ladder_lines)
       lines.concat(coverage_policy_lines)
+      lines.concat(changed_scope_lines)
+      lines.concat(collation_lines)
       lines << missing_summary_line if @missing_only
       selected_decisions, hidden = selected_decisions_for_display
       append_selection_lines(lines, hidden, "decision")
@@ -189,7 +359,7 @@ module Branchproof
       selected_decisions.each { |decision| render_decision(lines, decision) }
       render_minima(lines) unless @missing_only
       unless @diagnostics.empty?
-        lines << "Diagnostics:"
+        lines << (@changed_scope ? "Run-wide diagnostics:" : "Diagnostics:")
         @diagnostics.each { |diagnostic| lines << "  - #{diagnostic_message(diagnostic)}" }
       end
       lines.join("\n") << "\n"
@@ -198,6 +368,7 @@ module Branchproof
     def render_decision(lines, decision)
       source = source_for(decision)
       filename = value(source, :relative_path) || value(source, :absolute_path) || value(decision, :source_id)
+      filename = display_scope_path(filename)
       decision_label = "Decision #{short_id(value(decision, :id))} #{filename}:#{value(decision, :line)}"
       lines << decision_label
       lines << "  Decision: #{value(decision, :expression)}"
@@ -528,7 +699,7 @@ module Branchproof
         "  #{label} (#{value(minimum, :status)}, decisions: [#{scope}]): #{selected}"
       end.uniq
       unless rows.empty?
-        lines << "Supporting sets:"
+        lines << (@changed_scope ? "Whole-run supporting sets:" : "Supporting sets:")
         lines.concat(rows)
       end
       lines << "Additional tests outside this MC/DC evidence set may improve coverage." unless @minima.empty?
@@ -710,7 +881,7 @@ module Branchproof
       end
     end
 
-    def condition_detail(decision, _condition, result)
+    def condition_detail(decision, condition, result)
       return "" unless result && (@level == 3 || @missing_only)
 
       pair = value(result, :canonical_pair)
@@ -725,15 +896,15 @@ module Branchproof
         candidates = Array(value(constraint, :candidate_vectors))
         existing = existing_vector_for(constraint)
         unless candidates.empty?
-          detail_lines = [" — missing observation"]
+          detail_lines = []
+          status = value(constraint, :status).to_s
+          if !status.empty? && status != "CANDIDATE"
+            detail_lines << " — Constraint status: #{status}; candidate suggestions follow"
+          end
           candidates.each do |candidate|
-            detail_lines << "      Need an observation where:"
-            detail_lines.concat(candidate_requirements(decision, candidate).map { |item| "        #{item}" })
-            outcome = value(candidate, :outcome) ? "true" : "false"
-            detail_lines << "        Expected decision: #{outcome} [#{vector_values(candidate)}]"
+            detail_lines.concat(missing_evidence_lines(decision, condition, candidate, existing))
           end
           detail_lines << "      #{statement}" unless statement.to_s.empty?
-          detail_lines << "      Compare with: #{existing_vector_context(existing)}"
           return detail_lines.join("\n")
         end
         unless existing.nil?
@@ -749,6 +920,95 @@ module Branchproof
       ""
     end
 
+    def missing_evidence_lines(decision, condition, candidate, existing)
+      target_index = value(condition, :index).to_i
+      target_expression = value(condition, :expression) || "condition #{target_index}"
+      lines = [" — Missing evidence for: #{target_expression}"]
+      unless existing
+        lines << "      Candidate requirements (not observed):"
+        lines << "      Need an observation where:"
+        Array(value(candidate, :values)).each_with_index do |required, index|
+          expression = condition_expression(decision, index) || "condition #{index}"
+          requirement = if required.nil?
+                          "is not evaluated (short-circuited)"
+                        else
+                          "is #{required ? "truthy" : "falsey"}"
+                        end
+          lines << "        #{expression} #{requirement}"
+        end
+        expected_outcome = value(candidate, :outcome)
+        unless expected_outcome.nil?
+          lines << "      Expected decision: #{boolean_word(expected_outcome)} [#{vector_values(candidate)}]"
+        end
+        lines << "      Candidate combination (not observed): #{candidate_values_text(decision, candidate)}"
+        return lines
+      end
+
+      existing_values = Array(value(existing, :values))
+      candidate_values = Array(value(candidate, :values))
+      observed_target = existing_values[target_index]
+      candidate_target = candidate_values[target_index]
+      lines << "      Observed decision expression: #{value(decision, :expression)}"
+      lines << "      Find two executions where:"
+      target_requirement = if observed_target.nil? || candidate_target.nil?
+                             "#{target_expression} is not evaluated in one execution (short-circuited); " \
+                               "no Boolean flip can be claimed"
+                           else
+                             "#{target_expression} changes between #{boolean_word(observed_target)} and " \
+                               "#{boolean_word(candidate_target)}"
+                           end
+      lines << "        #{target_requirement}"
+      Array(value(decision, :conditions)).each_with_index do |item, index|
+        next if index == target_index
+
+        before = existing_values[index]
+        after = candidate_values[index]
+        expression = value(item, :expression) || "condition #{index}"
+        if !before.nil? && before == after
+          lines << "        #{expression} remains #{boolean_word(before)}"
+        elsif !before.nil? && !after.nil? && before != after
+          lines << "        #{expression} also changes from #{boolean_word(before)} to #{boolean_word(after)}"
+        elsif before.nil? || after.nil?
+          lines << "        #{expression} is not evaluated (short-circuited) in one execution"
+        end
+      end
+      before_outcome = value(existing, :outcome)
+      after_outcome = value(candidate, :outcome)
+      outcome_requirement = if before_outcome.nil? || after_outcome.nil?
+                              "decision outcome is unavailable for one execution"
+                            elsif before_outcome != after_outcome
+                              "decision outcome changes between #{boolean_word(before_outcome)} and " \
+                                "#{boolean_word(after_outcome)}"
+                            else
+                              "decision outcome remains #{boolean_word(before_outcome)}"
+                            end
+      lines << "        #{outcome_requirement}"
+      lines << "      Observed: #{candidate_values_text(decision, existing)}#{existing_owner_suffix(existing)}"
+      lines << "      Missing counterpart: #{candidate_values_text(decision, candidate)} (candidate; not observed)"
+      lines
+    end
+
+    def existing_owner_suffix(existing)
+      owner_ids = Array(value(existing, :test_ids))
+      owners = owner_ids.first(2).map { |id| test_label(id) }
+      owners << "#{owner_ids.length - 2} more" if owner_ids.length > 2
+      owners.empty? ? "" : " (#{owners.join(", ")})"
+    end
+
+    def candidate_values_text(decision, vector)
+      values = Array(value(vector, :values)).each_with_index.map do |item, index|
+        expression = condition_expression(decision, index) || "condition #{index}"
+        "#{expression} = #{item.nil? ? "not evaluated (short-circuited)" : boolean_word(item)}"
+      end
+      outcome = value(vector, :outcome)
+      values << "decision = #{outcome.nil? ? "unavailable" : boolean_word(outcome)}"
+      values.join("; ")
+    end
+
+    def boolean_word(value)
+      value ? "true" : "false"
+    end
+
     def readable_constraints(decision, constraint)
       Array(value(constraint, :constraints)).filter_map do |item|
         if item.respond_to?(:key?)
@@ -768,17 +1028,6 @@ module Branchproof
       value(condition, :expression)
     end
 
-    def candidate_requirements(decision, candidate)
-      Array(value(candidate, :values)).each_with_index.map do |required, index|
-        expression = condition_expression(decision, index) || "condition #{index}"
-        if required.nil?
-          "#{expression} is not evaluated (short-circuited)"
-        else
-          "#{expression} is #{required ? "truthy" : "falsey"}"
-        end
-      end
-    end
-
     def vector_values(vector)
       Array(value(vector, :values)).map do |item|
         if item.nil?
@@ -791,16 +1040,6 @@ module Branchproof
       end.join
     end
 
-    def existing_vector_context(existing)
-      return "no existing effective observation" unless existing
-
-      owner_ids = Array(value(existing, :test_ids))
-      owners = owner_ids.first(2).map { |id| test_label(id) }
-      owners << "#{owner_ids.length - 2} more" if owner_ids.length > 2
-      context = "[#{vector_values(existing)}] => #{value(existing, :outcome) ? "true" : "false"}"
-      owners.empty? ? context : "#{context} (#{owners.join(", ")})"
-    end
-
     def existing_vector_for(constraint)
       id = value(constraint, :existing_vector_id).to_s
       return if id.empty?
@@ -937,19 +1176,26 @@ module Branchproof
     end
 
     def decisions_to_render
-      return inventory_decisions unless @missing_only
-      return [] unless analysis_available?
-
-      inventory_decisions
-        .reject { |decision| unsupported?(decision) }
-        .select do |decision|
-          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
+      decisions = if !@missing_only
+                    inventory_decisions
+                  elsif !analysis_available?
+                    []
+                  else
+                    inventory_decisions
+                      .reject { |decision| unsupported?(decision) }
+                      .select do |decision|
+                        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
+      return decisions unless @selection.decision_ids
+
+      inventory = value(@inventory, :source_units) ? @inventory : { source_units: [], decisions: inventory_decisions }
+      @selection.filter_decisions(decisions, inventory: inventory)
     end
 
     def selected_decisions_for_display
@@ -964,11 +1210,17 @@ module Branchproof
 
     def append_selection_lines(lines, hidden, unit)
       if @selection.focus_active?
-        matching = @selection.matching_decision_ids(json_document)
+        matching = if @changed_scope
+                     @selection.selected_decision_ids(json_document)
+                   else
+                     @selection.matching_decision_ids(json_document)
+                   end
+        focus_label = display_scope_path(@selection.focus_label)
+        no_match = @changed_scope ? "no matching changed decisions" : "no matching decisions"
         lines << if matching.empty?
-                   "Focus: no matching decisions for #{@selection.focus_label}"
+                   "Focus: #{no_match} for #{focus_label}"
                  else
-                   "Focus: #{@selection.focus_label}"
+                   "Focus: #{focus_label}"
                  end
       end
       return unless @selection.top
@@ -1049,6 +1301,32 @@ module Branchproof
       base.merge(@minimum_override || {})
     end
 
+    def normalize_minimum_changed(minimum)
+      return nil if minimum.nil? || minimum.empty?
+
+      CoveragePolicy.normalize(minimum)
+    end
+
+    def effective_minimum_changed
+      inherited = value(value(@saved_document, :changed_coverage_policy), :minimum_changed)
+      base = inherited.is_a?(Hash) ? normalize_minimum_changed(inherited) : {}
+      base.merge(@minimum_changed_override || {})
+    end
+
+    def changed_coverage_policy
+      @changed_coverage_policy ||= ChangedCoveragePolicy.new(minimum_changed: @minimum_changed).call(
+        document: policy_document, scope: @changed_scope
+      )
+    end
+
+    def changed_coverage_summary
+      @changed_coverage_summary ||= if @saved_document
+                                      value(@saved_document, :changed_coverage)
+                                    else
+                                      ChangedCoverage.call(document: policy_document, scope: @changed_scope)
+                                    end
+    end
+
     def coverage_available?
       analysis_available? && !value(@analysis, :coverage).nil?
     end
@@ -1148,6 +1426,10 @@ 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?
+      if @changed_scope && (!changed_coverage_available? ||
+                            (@selection.focus_active? && @selection.selected_decision_ids(json_document).empty?))
+        return "Changed-scope missing coverage unavailable from the captured evidence"
+      end
 
       unavailable = unavailable_decision_table_count
       unavailable_suffix = if unavailable.positive?
@@ -1208,6 +1490,13 @@ module Branchproof
       @inventory_decisions ||= Array(value(@inventory, :decisions)).freeze
     end
 
+    def inventory_decisions_by_id
+      @inventory_decisions_by_id ||= inventory_decisions.each_with_object({}) do |decision, index|
+        id = value(decision, :id).to_s
+        index[id] = decision unless index.key?(id)
+      end
+    end
+
     def vectors
       @vectors ||= Array(value(@evidence, :vectors)).freeze
     end
@@ -1257,8 +1546,31 @@ module Branchproof
     def normalize_unknown(object)
       object.to_s
     end
-    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_policy_lines, :coverage_policy,
-           :coverage_status_label,
+
+    def changed_coverage_reason(row)
+      reason = value(row, :reason)
+      {
+        "empty_scope" => "no decisions matched the changed files",
+        "unsupported_only" => "all changed decisions are unsupported",
+        "baseline_unavailable" => "the test run is incomplete",
+        "incomplete_document" => "the report is incomplete",
+        "incomplete_observations" => "observation evidence is incomplete",
+        "incomplete_analysis" => "analysis evidence is incomplete",
+        "analysis_unavailable" => "analysis is unavailable",
+        "missing_selected_analysis" => "analysis is missing for changed decisions",
+        "missing_selected_coverage" => "coverage is missing for changed decisions",
+        "decision_table_not_calculated" => "decision table analysis was not calculated",
+        "zero_denominator" => "not applicable"
+      }.fetch(reason.to_s, "the captured evidence is unavailable")
+    end
+
+    def scope_text(text)
+      text.to_s.scrub.gsub(/[[:cntrl:]]/) { |character| "\\u{#{character.ord.to_s(16).upcase}}" }
+    end
+    public :condition_coverage_evidence, :changed_scope_lines, :collation_lines, :coverage_ladder_lines,
+           :coverage_policy_lines, :coverage_policy, :changed_coverage_policy, :coverage_status_label,
+           :changed_coverage_available?,
+           :display_scope_path,
            :decision_table_requirement, :decision_table_reachability, :decision_table_expected_heading
   end
 end