branchproof 0.3.0 → 0.4.0

data/lib/branchproof/comparison_report.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+require "json"
+
+module Branchproof
+  # Renders the offline document returned by Comparison.
+  class ComparisonReport
+    def initialize(document:)
+      raise ArgumentError, "comparison document must be a Hash" unless document.is_a?(Hash)
+
+      @document = document
+    end
+
+    def write(io:, format:)
+      format = format.to_sym
+      raise ArgumentError, "format must be :terminal or :json" unless %i[terminal json].include?(format)
+
+      io.write(format == :json ? JSON.generate(@document) : terminal_document)
+      nil
+    end
+
+    def exit_code(fail_on_regression: false)
+      return 2 if status != "complete"
+      return 1 if fail_on_regression && regression?
+
+      0
+    end
+
+    private
+
+    def terminal_document
+      lines = ["Branchproof comparison", "Status: #{status}"]
+      reasons.each { |reason| lines << "Reason: #{reason}" }
+      Array(value(:context)).each { |item| lines << "Context: #{item}" }
+      lines << "Conditions: #{matching.fetch("matched_conditions",
+                                             0)} matched (denominator #{matching.fetch("denominator", 0)})"
+      lines << "Before: #{summary_status(before)}; After: #{summary_status(after)}"
+      lines << "Full-run totals: before #{totals(before)}; after #{totals(after)}"
+      before_total = "#{matching["before_proven"] || 0}/#{matching["denominator"] || 0}"
+      after_total = "#{matching["after_proven"] || 0}/#{matching["denominator"] || 0}"
+      lines << "Exact-match totals: before #{before_total} proven; after #{after_total} proven"
+      lines << "No comparable conditions." if matching.fetch("matched_conditions", 0).zero?
+      changed_sources.each { |source| lines << "Source changed: #{source["relative_path"]}" }
+      newly.each { |path| lines << "Newly in report: #{path}" }
+      removed.each { |path| lines << "No longer in report: #{path}" }
+      rendered_changes = changes.reject { |change| change["change"] == "unchanged" }
+      if rendered_changes.empty?
+        lines << "No comparable condition changes."
+      else
+        rendered_changes.each do |change|
+          location = if change["relative_path"].to_s.empty?
+                       "location unavailable"
+                     else
+                       "#{change["relative_path"]}:#{change["line"] || "condition line unavailable"}"
+                     end
+          lines << "#{change["change"].capitalize}: #{location} (condition #{change["index"]}) #{change["expression"]}"
+          next unless change["change"] == "lost proof"
+
+          owners = Array(change["previous_witness"]).flat_map { |witness| Array(witness["tests"]) }.uniq
+          lines << "  Previous owners: #{owners.empty? ? "unavailable" : owners.join(", ")}"
+          Array(change["previous_witness"]).each do |witness|
+            outcome = witness["outcome"] ? "T" : "F"
+            owners = Array(witness["tests"]).join(", ")
+            lines << "  Previous witness: [#{signs(witness["values"])}] => #{outcome} — #{owners}"
+          end
+          context = Array(change["owner_context"]).map do |item|
+            "#{item["label"]}: #{item["test_status"]}; [#{signs(item["values"])}] => " \
+              "#{item["outcome"] ? "T" : "F"} #{item["observation_status"]}"
+          end
+          lines << "  #{context.empty? ? "not observed in current run" : context.join(", ")}"
+        end
+      end
+      lines.join("\n") << "\n"
+    end
+
+    def status = value(:status).to_s
+
+    def signs(values)
+      Array(values).map do |item|
+        if item.nil?
+          "-"
+        else
+          (item ? "T" : "F")
+        end
+      end.join
+    end
+
+    def totals(summary)
+      metrics = value_from(summary, :metrics) || {}
+      "#{value_from(metrics,
+                    :proven) || "unknown"}/#{value_from(metrics, :eligible_conditions) || "unknown"} conditions proven"
+    end
+
+    def regression? = value(:regression) == true || value(:regressions).to_i.positive?
+    def reasons = Array(value(:reasons))
+    def matching = value(:matching) || {}
+    def before = value(:before) || {}
+    def after = value(:after) || {}
+    def changes = Array(value(:changes))
+    def changed_sources = Array(value(:changed_sources))
+    def newly = Array(value(:newly_in_report))
+    def removed = Array(value(:no_longer_in_report))
+
+    def summary_status(summary)
+      value_from(summary, :status).to_s.upcase.then { |item| item.empty? ? "unknown" : item }
+    end
+
+    def value(key) = value_from(@document, key)
+
+    def value_from(hash, key)
+      return nil unless hash.respond_to?(:key?)
+
+      hash.key?(key) ? hash[key] : hash[key.to_s]
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/coverage_index.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+
+require "pathname"
+
+module Branchproof
+  # Derives condition- and test-oriented rows from one report document.
+  class CoverageIndex
+    attr_reader :conditions, :tests
+
+    def initialize(document:)
+      @document = symbolize(document || {})
+      @inventory = symbolize(@document[:source_inventory] || @document[:inventory] || {})
+      @evidence = symbolize(@document[:observations] || @document[:evidence] || {})
+      @analysis = symbolize(@document[:analysis] || {})
+      @baseline = symbolize(@document[:baseline] || {})
+      @vectors = records(@evidence, :vectors)
+      @vectors_by_decision = @vectors.group_by { |vector| vector[:decision_id].to_s }
+      @vectors_by_id = @vectors.to_h { |vector| [vector[:id].to_s, vector] }
+      @analysis_by_decision = records(@analysis, :decisions).to_h { |decision| [decision[:decision_id].to_s, decision] }
+      @source_units_by_id = records(@inventory, :source_units).to_h { |unit| [unit[:source_id].to_s, unit] }
+      @test_locations = symbolize(@document[:run_metadata] || {})[:test_locations] || {}
+      @tests_by_id = {}
+      (records(@evidence, :tests) + records(@baseline, :tests)).each do |test|
+        id = test[:id].to_s
+        @tests_by_id[id] = (@tests_by_id[id] || {}).merge(test) unless id.empty?
+      end
+      @conditions = build_conditions.freeze
+      @tests = build_tests.freeze
+    end
+
+    private
+
+    def build_conditions
+      decisions = records(@inventory, :decisions)
+      rows = decisions.flat_map do |decision|
+        next [] if decision[:support_status].to_s == "UNSUPPORTED"
+
+        source = @source_units_by_id[decision[:source_id].to_s] || {}
+        result_map = records(analysis_for(decision), :condition_results).to_h do |result|
+          [result[:condition_id].to_s, result]
+        end
+        records(decision, :conditions).map do |condition|
+          condition = symbolize(condition)
+          result = symbolize(result_map[condition[:id].to_s] || {})
+          pair = Array(result[:canonical_pair])
+          vectors = @vectors_by_decision[decision[:id].to_s] || []
+          observations = { true => [], false => [], short_circuited: [], unattributed: [] }
+          vectors.each do |vector|
+            value = vector_values(vector)[condition[:index].to_i]
+            if value.nil?
+              observations[:short_circuited] << vector
+            elsif value == true
+              observations[true] << vector
+            elsif value == false
+              observations[false] << vector
+            end
+            observations[:unattributed] << vector if vector[:unattributed_count].to_i.positive?
+          end
+          {
+            id: condition[:id], decision_id: decision[:id], index: condition[:index],
+            expression: condition[:expression],
+            line: condition[:line], column: condition[:column], relative_path: relative_path(source[:relative_path]),
+            decision_expression: decision[:expression],
+            status: @document[:analysis] ? (result[:status] || "NOT_PROVEN") : "NOT CALCULATED",
+            observed_true: test_ids(observations[true]), observed_false: test_ids(observations[false]),
+            short_circuited: test_ids(observations[:short_circuited]),
+            unattributed: observations[:unattributed].sum { |vector| vector[:unattributed_count].to_i },
+            witness_vector_ids: pair, witness_owners: pair.flat_map { |id| owners_for(id) }.uniq.sort,
+            witness_owner_details: pair.flat_map { |id| owner_details_for(id) }.uniq.sort,
+            vectors: observations, constraint_result: result[:constraint_result],
+            supporting_set: supporting_set_for(decision[:id]), unexecuted: vectors.empty?
+          }
+        end
+      end
+      rows.sort_by do |row|
+        [row[:relative_path].to_s, row[:line].to_i, row[:column].to_i,
+         row[:decision_id].to_s, row[:index].to_i]
+      end
+    end
+
+    def build_tests
+      by_id = @tests_by_id.transform_values do |test|
+        { id: test[:id], name: display_name(test), relative_path: test_location(test)[0], line: test_location(test)[1],
+          status: test[:status], phases: Array(test[:phase_counts]).to_h.keys.sort,
+          observations: [], owns_witness: false }
+      end
+      @conditions.each do |condition|
+        condition[:vectors].each do |kind, vectors|
+          next if kind == :unattributed
+
+          vectors.each do |vector|
+            Array(vector[:test_ids]).each do |id|
+              row = by_id[id.to_s] ||= { id: id, name: id, relative_path: nil, line: nil, status: "unknown",
+                                         phases: [], observations: [], owns_witness: false }
+              phase_map = symbolize(vector[:phases_by_test] || {})
+              phases = phase_map[id.to_s] || phase_map[id.to_sym] || []
+              row[:phases] |= Array(phases).map(&:to_s)
+              row[:observations] << { condition_id: condition[:id], expression: condition[:expression],
+                                      relative_path: condition[:relative_path], line: condition[:line],
+                                      value: kind == :short_circuited ? nil : (kind == true), kind: kind,
+                                      phases: phases.map(&:to_s).sort,
+                                      owns_witness: condition[:witness_vector_ids].include?(vector[:id]) }
+              row[:owns_witness] = true if condition[:witness_vector_ids].include?(vector[:id])
+            end
+          end
+        end
+      end
+      by_id.each_value do |row|
+        row[:observations].uniq!
+        row[:phases] = row[:phases].map(&:to_s).uniq.sort
+      end
+      by_id.values.sort_by { |row| [row[:name].to_s, row[:relative_path].to_s, row[:line].to_i, row[:id].to_s] }
+    end
+
+    def analysis_for(decision)
+      @analysis_by_decision[decision[:id].to_s] || {}
+    end
+
+    def supporting_set_for(decision_id)
+      Array(@document[:minima] || @document["minima"]).filter_map do |minimum|
+        minimum = symbolize(minimum)
+        next unless minimum[:objective].to_s == "tests"
+        next unless Array(minimum[:scope_decision_ids]).map(&:to_s).include?(decision_id.to_s)
+
+        Array(minimum[:selected_ids]).map(&:to_s).sort
+      end.first || []
+    end
+
+    def owners_for(vector_id)
+      vector = @vectors_by_id[vector_id.to_s]
+      Array(vector && vector[:test_ids]).map { |id| display_name(@tests_by_id[id.to_s] || { id: id }) }
+    end
+
+    def owner_details_for(vector_id)
+      vector = @vectors_by_id[vector_id.to_s]
+      Array(vector && vector[:test_ids]).map do |id|
+        test = @tests_by_id[id.to_s] || { id: id }
+        name = display_name(test)
+        path, line = test_location(test)
+        path && line ? "#{name} (#{path}:#{line})" : name
+      end
+    end
+
+    def test_ids(vectors) = vectors.flat_map { |vector| Array(vector[:test_ids]) }.map(&:to_s).uniq.sort
+    def vector_values(vector) = Array(vector[:values])
+    def records(hash, key) = Array(hash[key] || hash[key.to_s]).map { |item| symbolize(item) }
+
+    def display_name(test)
+      return "#{test[:class_name]}##{test[:method_name]}" if test[:class_name] && test[:method_name]
+
+      (test[:name] || test[:id]).to_s
+    end
+
+    def test_location(test)
+      saved = symbolize(@test_locations[test[:id].to_s] || @test_locations[test[:id].to_sym] || {})
+      return [relative_path(saved[:relative_path]), saved[:line]] unless saved.empty?
+
+      source = symbolize(test[:source] || {})
+      path = source[:relative_path] || source[:path] || test[:source_path]
+      [relative_path(path), source[:line] || test[:line] || test[:source_line]]
+    end
+
+    def relative_path(path)
+      return nil if path.nil? || path.to_s.empty?
+      return path.to_s unless Pathname.new(path.to_s).absolute?
+
+      root = @inventory[:root] || symbolize(@document[:run_metadata] || {})[:project_root]
+      return nil unless root && Pathname.new(root.to_s).absolute?
+
+      Pathname.new(path.to_s).relative_path_from(Pathname.new(root.to_s)).to_s
+    rescue ArgumentError
+      nil
+    end
+
+    def symbolize(value)
+      case value
+      when Hash then value.each_with_object({}) { |(key, item), result| result[key.to_sym] = symbolize(item) }
+      when Array then value.map { |item| symbolize(item) }
+      else value
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength

data/lib/branchproof/focused_report.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+require "pathname"
+
+module Branchproof
+  # Terminal renderings grouped around conditions or tests.
+  class FocusedReport
+    def initialize(document:, view:, level:, missing_only: false)
+      @document = document || {}
+      @view = view.to_sym
+      raise ArgumentError, "view must be :conditions or :tests" unless %i[conditions tests].include?(@view)
+
+      @level = level.to_i
+      @missing_only = missing_only ? true : false
+      @index = CoverageIndex.new(document: @document)
+      @tests = @index.tests.to_h { |test| [test[:id].to_s, test] }
+      @coordinator = Report.from_document(document: @document, level: @level)
+    end
+
+    def render
+      baseline = fetch(@document, :baseline) || {}
+      completeness = fetch(@document, :completeness) || {}
+      evidence = fetch(@document, :observations) || {}
+      lines = ["Branchproof focused view: #{@view}", "Tests: #{fetch(baseline, :status) || "INCOMPLETE"}",
+               "Values: T=true, F=false, -=short-circuited"]
+      if completeness.values.include?(false) || fetch(baseline, :status).to_s != "PASSED"
+        lines << "Warning: failed or incomplete run; observations and proof evidence may be unavailable."
+      end
+      aborts = fetch(evidence, :abort_counts)
+      abort_count = aborts.is_a?(Hash) ? aborts.values.sum(&:to_i) : aborts.to_i
+      if abort_count.positive?
+        lines << "Warning: #{abort_count} aborted observations; completed vectors do not describe aborted evaluations."
+      end
+      lines << "Empty groups mean no recorded completed observation."
+      lines << ""
+      @view == :conditions ? render_conditions(lines) : render_tests(lines)
+      render_unowned(lines)
+      render_unsupported(lines)
+      Array(fetch(@document, :diagnostics)).each do |diagnostic|
+        lines << "Diagnostic: #{fetch(diagnostic, :message) || fetch(diagnostic, :code)}"
+      end
+      lines.join("\n") << "\n"
+    end
+
+    private
+
+    def render_conditions(lines)
+      rows = @index.conditions
+      rows = rows.reject { |row| row[:status].to_s.upcase == "PROVEN" } if @missing_only && @level > 1
+      rows.each do |row|
+        lines << "Condition: #{row[:expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
+        lines << "Decision: #{row[:decision_expression]} (condition #{row[:index]})"
+        lines << "MC/DC: #{@level == 1 ? "NOT CALCULATED" : (row[:status] || "NOT_PROVEN")}"
+        render_group(lines, "Evaluated true by", row[:observed_true], row)
+        render_group(lines, "Evaluated false by", row[:observed_false], row)
+        render_group(lines, "Short-circuited in", row[:short_circuited], row)
+        lines << "  Unattributed observations: #{row[:unattributed]}" if row[:unattributed].to_i.positive?
+        if @level >= 2 && row[:supporting_set].any?
+          lines << "  Supporting test set: #{row[:supporting_set].map { |id| test_label(id) }.join(", ")}"
+          lines << "  Tests outside this MC/DC evidence set may provide other coverage."
+        end
+        render_constraint(lines, row) if @level >= 3 && row[:constraint_result]
+        if @level >= 3 && row[:witness_vector_ids].any?
+          lines << "  Witness observations (owners of example evidence):"
+          row[:witness_vector_ids].each do |id|
+            vector = row[:vectors].values.flatten.find { |item| item[:id].to_s == id.to_s }
+            next unless vector
+
+            owners = Array(vector[:test_ids]).map { |test_id| test_label(test_id) }.uniq.sort
+            owners << "unattributed" if vector[:unattributed_count].to_i.positive?
+            owners = owners.join(", ")
+            lines << "    [#{values(vector)}] => #{vector[:outcome] ? "T" : "F"} — #{owners}"
+          end
+        end
+        lines << ""
+      end
+      lines << "No missing conditions" if @missing_only && rows.empty?
+    end
+
+    def render_constraint(lines, row)
+      lines << @coordinator.condition_explanation(decision_id: row[:decision_id], condition_id: row[:id])
+    end
+
+    def render_group(lines, heading, ids, _row)
+      lines << "  #{heading}:"
+      if ids.empty?
+        lines << "    none recorded"
+      else
+        ids.each { |id| lines << "    #{test_label(id)}" }
+      end
+    end
+
+    def render_tests(lines)
+      rows = @index.tests
+      missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
+      rows.each { |row| render_test_row(lines, row, missing_ids) }
+    end
+
+    def render_test_row(lines, row, missing_ids)
+      observations = row[:observations]
+      if @missing_only
+        observations = observations.select { |observation| missing_ids.include?(observation[:condition_id]) }
+        return if observations.empty?
+      end
+      lines << "Test: #{row[:name]}"
+      lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "location unavailable")}"
+      lines << "Status: #{row[:status] || "unknown"}"
+      lines << "Phases: #{row[:phases].join(", ")}" unless row[:phases].empty?
+      render_test_observations(lines, observations)
+      lines << ""
+    end
+
+    def render_test_observations(lines, observations)
+      if observations.empty?
+        lines << "  No recorded completed condition observations"
+        return
+      end
+      observations.group_by { |observation| observation[:condition_id] }.each_value do |items|
+        observation = items.first
+        observed_values = items.map { |item| item[:value] }.uniq
+        label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
+        label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
+        phases = items.flat_map { |item| item[:phases] }.uniq.sort.join(", ")
+        signs = values(values: observed_values)
+        condition_location = location(observation[:relative_path], observation[:line],
+                                      unavailable: "condition line unavailable")
+        lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
+                 "phases: #{phases}"
+      end
+    end
+
+    def render_unowned(lines)
+      rows = @index.conditions
+      rows = rows.reject { |row| row[:status] == "PROVEN" } if @missing_only
+      { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
+        "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }.each do |heading, conditions|
+        next if conditions.empty?
+
+        lines << "#{heading}:"
+        conditions.each do |row|
+          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line],
+                                                      unavailable: "condition line unavailable")})"
+        end
+      end
+    end
+
+    def render_unsupported(lines)
+      inventory = fetch(@document, :source_inventory) || {}
+      sources = Array(fetch(inventory, :source_units)).to_h { |source| [fetch(source, :source_id), source] }
+      excluded = Array(fetch(inventory, :decisions)).select do |decision|
+        fetch(decision, :support_status) == "UNSUPPORTED"
+      end
+      return if excluded.empty?
+
+      lines << "Unsupported conditions (MC/DC unavailable):"
+      excluded.each do |decision|
+        source = sources[fetch(decision, :source_id)] || {}
+        path = fetch(source, :relative_path)
+        path = nil if path && Pathname.new(path).absolute?
+        conditions = Array(fetch(decision, :conditions))
+        conditions = [{ expression: fetch(decision, :expression) }] if conditions.empty?
+        conditions.each do |condition|
+          label = location(path, fetch(condition, :line), unavailable: "condition line unavailable")
+          lines << "  #{fetch(condition, :expression)} (#{label})"
+        end
+      end
+    end
+
+    def location(path, line, unavailable: "location unavailable")
+      return "location unavailable" if path.to_s.empty?
+      return "#{path}: #{unavailable}" if line.nil?
+
+      "#{path}:#{line}"
+    end
+
+    def values(vector)
+      Array(vector[:values]).map do |item|
+        if item.nil?
+          "-"
+        else
+          (item ? "T" : "F")
+        end
+      end.join
+    end
+
+    def test_label(id)
+      test = @tests[id.to_s]
+      return id.to_s unless test
+
+      label = "#{test[:name]} (#{location(test[:relative_path], test[:line])})"
+      duplicates = @index.tests.count do |row|
+        [row[:name], row[:relative_path], row[:line]] == [test[:name], test[:relative_path], test[:line]]
+      end
+      duplicates > 1 ? "#{label} [#{id}]" : label
+    end
+
+    def fetch(hash, key)
+      hash.key?(key) ? hash[key] : hash[key.to_s]
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/report.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 require "json"
+require "pathname"
 
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
-    SCHEMA_VERSION = "1.0"
+    SCHEMA_VERSION = "1.1"
     CRITERION_VERSION = "masking_occurrence_v1"
 
-    def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3, missing_only: false)
+    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)
 
       @inventory = inventory || {}
       @evidence = evidence || {}
@@ -18,7 +22,20 @@ module Branchproof
       @baseline = baseline || {}
       @diagnostics = Array(diagnostics)
       @level = level.to_i
-      @missing_only = !!missing_only
+      @missing_only = missing_only ? true : false
+      @view = view.to_sym
+      @run_metadata = run_metadata || {}
+      @saved_document = saved_document
+    end
+
+    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"],
+          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,
+          run_metadata: data[:run_metadata] || data["run_metadata"], saved_document: data)
     end
 
     def write(io:, format:)
@@ -29,6 +46,18 @@ module Branchproof
       nil
     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 }
+      return "" unless decision
+
+      condition = Array(value(decision, :conditions)).find { |item| value(item, :id).to_s == condition_id.to_s }
+      return "" unless condition
+
+      @terminal_ids ||= terminal_ids
+      condition_detail(decision, condition, condition_result(decision, condition))
+    end
+
     def exit_code
       return 2 unless usage_valid?
 
@@ -36,6 +65,7 @@ module Branchproof
       return 2 if %w[ERROR INCOMPLETE].include?(status)
       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?
       return 2 unless valid_for_requested_level?
 
@@ -45,16 +75,24 @@ module Branchproof
     private
 
     def json_document
+      return normalize(@saved_document) if @saved_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, baseline: @baseline, observations: @evidence,
                 analysis: @level == 1 ? nil : @analysis, minima: @minima, metrics: metrics,
-                diagnostics: @diagnostics, completeness: completeness)
+                diagnostics: @diagnostics, completeness: completeness,
+                run_metadata: @run_metadata)
     end
 
     def terminal_document
+      unless @view == :decisions
+        return FocusedReport.new(document: json_document, view: @view, level: @level,
+                                 missing_only: @missing_only).render
+      end
+
       @terminal_ids = terminal_ids
       lines = ["Branchproof #{defined?(Branchproof::VERSION) ? Branchproof::VERSION : "unknown"}",
                "Tests: #{baseline_status} (#{baseline_test_counts})",
@@ -224,17 +262,32 @@ module Branchproof
     end
 
     def test_location(test)
+      saved_location = value(value(@run_metadata, :test_locations), value(test, :id))
+      return [relative_test_path(value(saved_location, :relative_path)), value(saved_location, :line)] if saved_location
+
       location = value(test, :source)
       source_line = nil
       if location.respond_to?(:key?)
         source_line = value(location, :line)
-        location = value(location, :path) || value(location, :relative_path)
+        location = value(location, :relative_path) || value(location, :path)
       end
       location ||= value(test, :source_path)
+      location = relative_test_path(location)
       line = value(test, :line) || value(test, :source_line) || source_line
       [location, line]
     end
 
+    def relative_test_path(path)
+      return path unless path && Pathname.new(path.to_s).absolute?
+
+      root = value(@inventory, :root) || value(@run_metadata, :project_root)
+      return nil unless root && Pathname.new(root.to_s).absolute?
+
+      Pathname.new(path.to_s).relative_path_from(Pathname.new(root.to_s)).to_s
+    rescue ArgumentError
+      nil
+    end
+
     def minimum_member_label(objective, id)
       objective.to_s == "tests" ? test_label(id) : short_id(id)
     end