branchproof 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a76f20e6504affb4e614eeca901b0ef515f8bbb0785a641cf437263cac2df418
-  data.tar.gz: 87373206990831eeba3c1a2317049a4679343b4e4770015fb3e322710c7035e9
+  metadata.gz: b5d48afceb9c6608abf5ebdb2aa6f402dd11b75f43421b49686cc49fd95641c3
+  data.tar.gz: 647789d869c3a01f1809eacc871df99e4e0f81c7d8e70ffdb27228f4fd5c797e
 SHA512:
-  metadata.gz: 97b1aca56ec2e2ed60f683e7647ce91ec85f3b8a2bbe457cf6844b0bd7db9b6117a126bce8ec74f04e4805dc147beef6b58fa003f74d73bd6e18884973115833
-  data.tar.gz: 1aac59c7cc767f9ef805cdcfecbe8e5e6628e25ea09cc8d862b32b0518f9aad89f6f8204b69d4183c75af1938e94a61e3ba980f6fa396bbff542b464bf371896
+  metadata.gz: b5f87cd4aee8588f7a86ba6a91730b7b4a787c256a0485f6dc278acbd948a5a1399669d0e2903371b28f1b7058e5339efb85fdb13d31110944e6462bdfe55b6a
+  data.tar.gz: fb81f01ba2e42014364959afcdce9c8cd218611299d8bbd27a0a9fd5ed1ce1f2d311993f834b9f960934deadab659848257010717c2bdcc6814ea01870f985e2

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-10
+
+- Report Decision, Condition, and Condition/Decision Coverage alongside
+  existing MC/DC evidence from one test execution.
+- Show explicit coverage counts, supporting tests, and missing Boolean
+  observations in decision, condition, and test views and JSON reports.
+- Calculate the same coverage criteria at every reporting level and retain
+  analysis in level-1 snapshots for offline inspection at higher detail.
+  Continue to support legacy snapshots without analysis at level 1.
+
+## [0.5.0] - 2026-09-10
+
+- Show source filenames beside diagnostics in decision, condition, and test
+  views, including reports rendered from saved JSON.
+- Explain when a selected file has no supported conditions to instrument and
+  include unsupported syntax reasons when its decisions cannot be instrumented.
+
 ## [0.4.0] - 2026-09-10
 
 - Added `branchproof` as the primary CLI command while retaining `mcdc` as a

data/README.md

@@ -97,7 +97,7 @@ For example, running the contents of the small `decision.rb` /
 with the terminal format produces a summary like this:
 
 ```text
-Branchproof 0.4.0
+Branchproof 0.5.0
 Tests: PASSED (3 tests, 0 failed, 0 skipped)
 MC/DC: 100.0% (2/2 conditions proven)
 Analysis: COMPLETE
@@ -126,6 +126,50 @@ Additional tests outside this MC/DC evidence set may improve coverage.
 The test execution still runs once for the selected level. Use `--format
 json` when a consumer needs the complete identifiers and versioned schema.
 
+### Coverage ladder
+
+Each successful `analyze` run calculates four criteria from the same completed
+observations. The report shows their status for each supported decision and
+aggregate counts with explicit denominators:
+
+| Criterion | Requirement | Aggregate denominator |
+| --- | --- | --- |
+| Decision | The decision produced both true and false | Supported decisions |
+| Condition | Every atomic condition evaluated both true and false | Two required truth values per supported condition |
+| Condition/Decision | Both Decision and Condition Coverage hold for a decision | Supported decisions |
+| MC/DC | Every condition has an independence witness pair | Supported conditions |
+
+For `logged_in? && admin?`, observations `[F-] => F` and `[TT] => T` give:
+
+```text
+Decision                    PASS
+Condition                   FAIL (3/4 values observed)
+Condition/Decision          FAIL
+MC/DC                       FAIL (1/2 conditions proven)
+```
+
+The skipped `admin?` in `[F-]` counts as neither true nor false. Conditions
+that did evaluate count toward Condition Coverage even when their value was
+masked by another condition. Here, the two observations prove independence
+for `logged_in?`; `admin?` still needs `[TF] => F`.
+
+Decision and Condition Coverage are calculated independently from the captured
+evidence. Condition/Decision requires both; MC/DC adds independence evidence.
+Unsupported decisions are excluded from every denominator, while
+unexecuted supported decisions remain in scope. Empty denominators are N/A.
+
+Reports retain the observations and owning tests for each decision outcome
+and condition value. Missing values describe required runtime observations,
+not application inputs or a guarantee that the path is reachable. Unattributed
+observations can provide truth-value evidence without identifying a test;
+the report's completeness and diagnostics still apply.
+
+JSON stores aggregate counts under `analysis.coverage`, per-decision results
+under `analysis.decisions[].coverage`, and condition value evidence under
+`analysis.decisions[].condition_results[].coverage`. Existing MC/DC witness
+pairs, counterpart constraints, and raw vectors remain available. Statuses
+distinguish `covered`, `partial`, `unexecuted`, and `unsupported` results.
+
 ### Find missing cases
 
 Use `--missing-only` to focus the terminal report on conditions that still
@@ -175,15 +219,17 @@ test inputs; they do not by themselves prove a bug in the application.
 
 The levels select how much of the one-run result is displayed:
 
-* Level 1 reports observed vectors grouped by their raw decision outcomes.
+* Level 1 reports the coverage ladder and observed vectors grouped by their
+  raw decision outcomes.
 * Level 2 includes the smallest supporting sets found for vectors and tests.
 * Level 3 (the default) includes condition independence witnesses and
   counterpart constraints, as well as the Level 1 and 2 evidence.
 
-Level 2 and Level 3 compute from the same captured run. They do not rerun the
-test suite. A failed, unsupported, or incomplete run is reported with its
-status and diagnostics and cannot become a successful coverage result by
-changing the display level.
+All levels calculate the same criteria from one captured run. The level
+controls displayed evidence, not the coverage criterion; JSON retains the
+analysis even at Level 1. A failed, unsupported, or incomplete run is reported
+with its status and diagnostics and cannot become a successful coverage
+result by changing the display level.
 
 ### Focused condition and test views
 
@@ -232,7 +278,8 @@ artifacts when you need to retain multiple runs.
 The `report` command reads the saved document without loading the application
 or running tests. It uses locations and metadata captured in the report, so
 rendering remains useful after the original checkout has moved or been
-removed. Level 1 reports observations; levels 2 and 3 require corresponding
+removed. New snapshots retain the ladder at every level. Legacy snapshots
+without analysis can still be rendered at Level 1; levels 2 and 3 require
 analysis in the saved report. The repository ignores `.branchproof/`; choose a
 different path and CI artifact policy when a project needs to retain reports.
 Saved JSON includes existing raw metadata such as test names and expressions;

data/doc/Branchproof/Report.md

@@ -19,9 +19,22 @@ Not documented.
 Not documented.
 
 ## Public Instance Methods
+### `condition_coverage_evidence(decision_id:, condition_id:)` <a id="method-i-condition_coverage_evidence"></a> <a id="condition_coverage_evidence-instance_method"></a>
+Returns condition-value evidence for focused renderers without exposing the
+report's internal document traversal or mutating saved records.
+
 ### `condition_explanation(decision_id:, condition_id:)` <a id="method-i-condition_explanation"></a> <a id="condition_explanation-instance_method"></a>
 Shares the existing missing-case wording with focused terminal views.
 
+### `coverage_ladder_lines()` <a id="method-i-coverage_ladder_lines"></a> <a id="coverage_ladder_lines-instance_method"></a>
+Render the shared ladder in every terminal view.
+
+### `coverage_status_label(status)` <a id="method-i-coverage_status_label"></a> <a id="coverage_status_label-instance_method"></a>
+Not documented.
+
+### `diagnostic_message(diagnostic)` <a id="method-i-diagnostic_message"></a> <a id="diagnostic_message-instance_method"></a>
+Formats source context consistently in live and saved terminal views.
+
 ### `exit_code()` <a id="method-i-exit_code"></a> <a id="exit_code-instance_method"></a>
 Not documented.
 

data/doc/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-10
+
+- Report Decision, Condition, and Condition/Decision Coverage alongside
+  existing MC/DC evidence from one test execution.
+- Show explicit coverage counts, supporting tests, and missing Boolean
+  observations in decision, condition, and test views and JSON reports.
+- Calculate the same coverage criteria at every reporting level and retain
+  analysis in level-1 snapshots for offline inspection at higher detail.
+  Continue to support legacy snapshots without analysis at level 1.
+
+## [0.5.0] - 2026-09-10
+
+- Show source filenames beside diagnostics in decision, condition, and test
+  views, including reports rendered from saved JSON.
+- Explain when a selected file has no supported conditions to instrument and
+  include unsupported syntax reasons when its decisions cannot be instrumented.
+
 ## [0.4.0] - 2026-09-10
 
 - Added `branchproof` as the primary CLI command while retaining `mcdc` as a

data/doc/README.md

@@ -97,7 +97,7 @@ For example, running the contents of the small `decision.rb` /
 with the terminal format produces a summary like this:
 
 ```text
-Branchproof 0.4.0
+Branchproof 0.5.0
 Tests: PASSED (3 tests, 0 failed, 0 skipped)
 MC/DC: 100.0% (2/2 conditions proven)
 Analysis: COMPLETE
@@ -126,6 +126,50 @@ Additional tests outside this MC/DC evidence set may improve coverage.
 The test execution still runs once for the selected level. Use `--format
 json` when a consumer needs the complete identifiers and versioned schema.
 
+### Coverage ladder
+
+Each successful `analyze` run calculates four criteria from the same completed
+observations. The report shows their status for each supported decision and
+aggregate counts with explicit denominators:
+
+| Criterion | Requirement | Aggregate denominator |
+| --- | --- | --- |
+| Decision | The decision produced both true and false | Supported decisions |
+| Condition | Every atomic condition evaluated both true and false | Two required truth values per supported condition |
+| Condition/Decision | Both Decision and Condition Coverage hold for a decision | Supported decisions |
+| MC/DC | Every condition has an independence witness pair | Supported conditions |
+
+For `logged_in? && admin?`, observations `[F-] => F` and `[TT] => T` give:
+
+```text
+Decision                    PASS
+Condition                   FAIL (3/4 values observed)
+Condition/Decision          FAIL
+MC/DC                       FAIL (1/2 conditions proven)
+```
+
+The skipped `admin?` in `[F-]` counts as neither true nor false. Conditions
+that did evaluate count toward Condition Coverage even when their value was
+masked by another condition. Here, the two observations prove independence
+for `logged_in?`; `admin?` still needs `[TF] => F`.
+
+Decision and Condition Coverage are calculated independently from the captured
+evidence. Condition/Decision requires both; MC/DC adds independence evidence.
+Unsupported decisions are excluded from every denominator, while
+unexecuted supported decisions remain in scope. Empty denominators are N/A.
+
+Reports retain the observations and owning tests for each decision outcome
+and condition value. Missing values describe required runtime observations,
+not application inputs or a guarantee that the path is reachable. Unattributed
+observations can provide truth-value evidence without identifying a test;
+the report's completeness and diagnostics still apply.
+
+JSON stores aggregate counts under `analysis.coverage`, per-decision results
+under `analysis.decisions[].coverage`, and condition value evidence under
+`analysis.decisions[].condition_results[].coverage`. Existing MC/DC witness
+pairs, counterpart constraints, and raw vectors remain available. Statuses
+distinguish `covered`, `partial`, `unexecuted`, and `unsupported` results.
+
 ### Find missing cases
 
 Use `--missing-only` to focus the terminal report on conditions that still
@@ -175,15 +219,17 @@ test inputs; they do not by themselves prove a bug in the application.
 
 The levels select how much of the one-run result is displayed:
 
-* Level 1 reports observed vectors grouped by their raw decision outcomes.
+* Level 1 reports the coverage ladder and observed vectors grouped by their
+  raw decision outcomes.
 * Level 2 includes the smallest supporting sets found for vectors and tests.
 * Level 3 (the default) includes condition independence witnesses and
   counterpart constraints, as well as the Level 1 and 2 evidence.
 
-Level 2 and Level 3 compute from the same captured run. They do not rerun the
-test suite. A failed, unsupported, or incomplete run is reported with its
-status and diagnostics and cannot become a successful coverage result by
-changing the display level.
+All levels calculate the same criteria from one captured run. The level
+controls displayed evidence, not the coverage criterion; JSON retains the
+analysis even at Level 1. A failed, unsupported, or incomplete run is reported
+with its status and diagnostics and cannot become a successful coverage
+result by changing the display level.
 
 ### Focused condition and test views
 
@@ -232,7 +278,8 @@ artifacts when you need to retain multiple runs.
 The `report` command reads the saved document without loading the application
 or running tests. It uses locations and metadata captured in the report, so
 rendering remains useful after the original checkout has moved or been
-removed. Level 1 reports observations; levels 2 and 3 require corresponding
+removed. New snapshots retain the ladder at every level. Legacy snapshots
+without analysis can still be rendered at Level 1; levels 2 and 3 require
 analysis in the saved report. The repository ignores `.branchproof/`; choose a
 different path and CI artifact policy when a project needs to retain reports.
 Saved JSON includes existing raw metadata such as test names and expressions;

data/lib/branchproof/analyzer.rb

@@ -30,7 +30,8 @@ module Branchproof
         proven_count: proven,
         eligible_count: eligible,
         completeness: completeness(decisions),
-        diagnostics: decisions.flat_map { |decision| decision[:diagnostics] } + @invalid_diagnostics
+        diagnostics: decisions.flat_map { |decision| decision[:diagnostics] } + @invalid_diagnostics,
+        coverage: aggregate_coverage(decisions)
       }.freeze
     end
 
@@ -97,7 +98,7 @@ module Branchproof
       unless id(decision, :support_status).to_s.empty? || id(decision, :support_status).to_s.upcase == "SUPPORTED"
         return {
           decision_id: decision_id, effective_masks_by_vector: {}, condition_results: [], witness_buckets: {},
-          conditions: [], unsupported: true,
+          conditions: [], unsupported: true, coverage: unsupported_coverage,
           completeness: { observation: true, attribution: true, analysis: true },
           diagnostics: [diagnostic("unsupported_decision", "warning", decision_id, nil)]
         }
@@ -136,9 +137,13 @@ module Branchproof
                     nil
                   else
                     (true_ids.empty? || false_ids.empty? ? "missing_effective_sign" : "no_independent_pair")
-                  end
+                  end,
+          coverage: condition_coverage(index, vectors)
         }
       end
+      decision_coverage = decision_coverage(vectors)
+      condition_coverage_summary = condition_summary(results)
+      mcdc = mcdc_coverage(results)
       {
         decision_id: decision_id,
         effective_masks_by_vector: masks,
@@ -146,11 +151,134 @@ module Branchproof
         witness_buckets: buckets,
         edge_table: edge_table(decision[:tree]),
         conditions: conditions(decision),
+        coverage: { decision: decision_coverage, condition: condition_coverage_summary,
+                    condition_decision: conjunction_coverage(decision_coverage, condition_coverage_summary),
+                    mcdc: mcdc },
         completeness: { observation: true, attribution: true, analysis: !@analysis_invalid },
         diagnostics: []
       }
     end
 
+    def unsupported_coverage
+      { decision: { status: "unsupported", true_observed: false, false_observed: false,
+                    covered_outcomes: 0, required_outcomes: 2, outcomes: [], missing_outcomes: [] },
+        condition: { status: "unsupported", covered_values: 0, required_values: 0,
+                     covered_conditions: 0, condition_count: 0 },
+        condition_decision: { status: "unsupported" },
+        mcdc: { status: "unsupported", proven_conditions: 0, condition_count: 0 } }
+    end
+
+    def provenance(vector)
+      { vector_id: id(vector, :id).to_s,
+        test_ids: Array(id(vector, :test_ids)).map(&:to_s).uniq.sort,
+        unattributed_count: id(vector, :unattributed_count).to_i }
+    end
+
+    def evidence_bucket(value, vectors)
+      matching = vectors.select do |vector|
+        observed?(vector, value[:index]) && self.value(vector, value[:index]) == value[:value]
+      end
+      evidence = matching.map { |vector| provenance(vector) }
+      { value: value[:value], observed: !matching.empty?,
+        vector_ids: evidence.flat_map { |item| item[:vector_id] }.uniq.sort,
+        test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+        unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+    end
+
+    def condition_coverage(index, vectors)
+      observed_vectors = vectors.select { |vector| observed?(vector, index) }
+      values = [true, false].map do |item|
+        evidence_bucket({ index: index, value: item }, observed_vectors)
+      end
+      covered = values.count { |entry| entry[:observed] }
+      { status: coverage_status(covered, 2), true_observed: values[0][:observed],
+        false_observed: values[1][:observed], covered_values: covered, required_values: 2,
+        values: values, missing_values: values.reject { |entry| entry[:observed] }.map { |entry| entry[:value] } }
+    end
+
+    def decision_coverage(vectors)
+      outcomes = [false, true].map do |value|
+        matching = vectors.select { |vector| outcome(vector) == value }
+        evidence = matching.map { |vector| provenance(vector) }
+        { value: value, observed: !matching.empty?,
+          vector_ids: evidence.flat_map { |item| item[:vector_id] }.uniq.sort,
+          test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+          unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+      end
+      covered = outcomes.count { |entry| entry[:observed] }
+      { status: coverage_status(covered, 2), true_observed: outcomes[1][:observed],
+        false_observed: outcomes[0][:observed], covered_outcomes: covered, required_outcomes: 2,
+        outcomes: outcomes,
+        missing_outcomes: outcomes.reject { |entry| entry[:observed] }.map { |entry| entry[:value] } }
+    end
+
+    def condition_summary(results)
+      values = results.sum { |result| result[:coverage][:covered_values] }
+      count = results.length
+      { status: coverage_status(values, count * 2), covered_values: values,
+        required_values: count * 2,
+        covered_conditions: results.count { |result| result[:coverage][:status] == "covered" },
+        condition_count: count }
+    end
+
+    def mcdc_coverage(results)
+      proven = results.count { |result| result[:status] == "PROVEN" }
+      observed = results.any? { |result| result[:coverage][:covered_values].positive? }
+      status = if !observed
+                 "unexecuted"
+               elsif proven == results.length
+                 "covered"
+               else
+                 "partial"
+               end
+      { status: status, proven_conditions: proven, condition_count: results.length }
+    end
+
+    def conjunction_coverage(decision, condition)
+      status = if decision[:status] == "covered" && condition[:status] == "covered"
+                 "covered"
+               elsif decision[:status] == "unexecuted" && condition[:status] == "unexecuted"
+                 "unexecuted"
+               else
+                 "partial"
+               end
+      { status: status }
+    end
+
+    def coverage_status(covered, required)
+      return "unexecuted" if covered.zero?
+      return "covered" if covered == required
+
+      "partial"
+    end
+
+    def aggregate_coverage(decisions)
+      supported = decisions.reject { |decision| decision[:unsupported] }
+      decision_covered = supported.count do |decision|
+        decision[:coverage][:decision][:status] == "covered"
+      end
+      condition_decision_covered = supported.count do |decision|
+        decision[:coverage][:condition_decision][:status] == "covered"
+      end
+      condition_count = supported.sum { |decision| decision[:coverage][:condition][:condition_count] }
+      condition_values = supported.sum { |decision| decision[:coverage][:condition][:covered_values] }
+      covered_conditions = supported.sum do |decision|
+        decision[:coverage][:condition][:covered_conditions]
+      end
+      proven = supported.sum { |decision| decision[:coverage][:mcdc][:proven_conditions] }
+      percentage = ->(covered, required) { required.zero? ? nil : (covered.to_f / required * 100).round(2) }
+      { decision: { covered_decisions: decision_covered, supported_decisions: supported.length,
+                    percentage: percentage.call(decision_covered, supported.length) },
+        condition: { covered_values: condition_values, required_values: condition_count * 2,
+                     covered_conditions: covered_conditions, condition_count: condition_count,
+                     percentage: percentage.call(condition_values, condition_count * 2) },
+        condition_decision: { covered_decisions: condition_decision_covered,
+                              supported_decisions: supported.length,
+                              percentage: percentage.call(condition_decision_covered, supported.length) },
+        mcdc: { proven_conditions: proven, supported_conditions: condition_count,
+                percentage: percentage.call(proven, condition_count) } }
+    end
+
     def valid_vector(vector, decision)
       return nil unless id(vector, :decision_id) == id(decision, :id)
 

data/lib/branchproof/cli.rb

@@ -49,7 +49,7 @@ module Branchproof
                                             message: merge_status[:reason].to_s }]
         end
       end
-      if options[:level] >= 2 && value(baseline, :status).to_s == "PASSED"
+      if value(baseline, :status).to_s == "PASSED"
         analysis = Analyzer.new(inventory: inventory, evidence: evidence.snapshot, limits: options[:limits]).call
         baseline[:analysis] = analysis
         if options[:level] >= 2
@@ -70,7 +70,7 @@ module Branchproof
       diagnostics = Array(value(inventory, :diagnostics)) + Array(value(baseline, :diagnostics)) +
                     Array(value(evidence.snapshot,
                                 :diagnostics)) + Array(value(value(baseline, :analysis), :diagnostics))
-      analysis = options[:level] == 1 ? nil : value(baseline, :analysis)
+      analysis = value(baseline, :analysis)
       minima = options[:level] == 1 ? [] : Array(value(baseline, :minima))
       report = Report.new(inventory: inventory, evidence: value(baseline, :evidence) || evidence.snapshot,
                           analysis: analysis, minima: minima, baseline: baseline, diagnostics: diagnostics,

data/lib/branchproof/focused_report.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 require "pathname"
 
 module Branchproof
@@ -34,11 +34,12 @@ module Branchproof
       end
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
+      lines.concat(@coordinator.coverage_ladder_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)}"
+        lines << "Diagnostic: #{@coordinator.diagnostic_message(diagnostic)}"
       end
       lines.join("\n") << "\n"
     end
@@ -52,7 +53,15 @@ module Branchproof
         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")}"
+        status = if @level == 1 && !coverage_available?
+                   "NOT CALCULATED"
+                 else
+                   row[:status] || "NOT_PROVEN"
+                 end
+        lines << "MC/DC: #{status}"
+        if @level >= 2
+          lines.concat(@coordinator.condition_coverage_evidence(decision_id: row[:decision_id], condition_id: row[:id]))
+        end
         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)
@@ -79,6 +88,11 @@ module Branchproof
       lines << "No missing conditions" if @missing_only && rows.empty?
     end
 
+    def coverage_available?
+      analysis = fetch(@document, :analysis)
+      analysis && fetch(analysis, :coverage)
+    end
+
     def render_constraint(lines, row)
       lines << @coordinator.condition_explanation(decision_id: row[:decision_id], condition_id: row[:id])
     end
@@ -202,4 +216,4 @@ module Branchproof
   end
 end
 
-# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/loader.rb

@@ -55,7 +55,7 @@ module Branchproof
       end
       unless rewritten[:changed]
         if Array(rewritten[:diagnostics]).empty?
-          add_diagnostic("not_instrumented", "selected source had no safe edits", unit[:source_id],
+          add_diagnostic("not_instrumented", unchanged_reason(unit), unit[:source_id],
                          severity: "info")
         end
         return nil
@@ -80,6 +80,14 @@ module Branchproof
 
     private
 
+    def unchanged_reason(unit)
+      decisions = Array(unit[:decisions])
+      reasons = decisions.flat_map { |decision| Array(decision[:support_reasons]) }.uniq
+      return "conditions cannot be instrumented: #{reasons.join(", ")}" unless reasons.empty?
+
+      "no supported conditions to instrument"
+    end
+
     def hook_supported?
       defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile)
     end

data/lib/branchproof/report.rb

@@ -58,6 +58,43 @@ module Branchproof
       condition_detail(decision, condition, condition_result(decision, condition))
     end
 
+    # Formats source context consistently in live and saved terminal views.
+    def diagnostic_message(diagnostic)
+      message = value(diagnostic, :message) || value(diagnostic, :code)
+      source_id = value(diagnostic, :source_id)
+      return message unless source_id
+
+      source = source_for(diagnostic)
+      path = value(source, :relative_path) || source_id
+      prefix = %w[not_instrumented unsupported_source].include?(value(diagnostic, :code).to_s) ? "Skipped " : ""
+      "#{prefix}#{path}: #{message}"
+    end
+
+    # Returns condition-value evidence for focused renderers without exposing
+    # the report's internal document traversal or mutating saved records.
+    def condition_coverage_evidence(decision_id:, condition_id:)
+      decision = inventory_decisions.find { |item| value(item, :id).to_s == decision_id.to_s }
+      condition = Array(value(decision, :conditions)).find do |item|
+        value(item, :id).to_s == condition_id.to_s
+      end
+      coverage = value(condition_result(decision, condition), :coverage)
+      return [] unless coverage
+
+      @terminal_ids ||= terminal_ids
+      lines = Array(value(coverage, :values)).map do |entry|
+        value_label = value(entry, :value) ? "true" : "false"
+        owners = Array(value(entry, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(entry, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        "  Value #{value_label}: #{value(entry, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_values))
+      unless missing.empty?
+        lines << "  Missing values: #{missing.map { |item| item ? "true" : "false" }.join(", ")}"
+      end
+      lines
+    end
+
     def exit_code
       return 2 unless usage_valid?
 
@@ -82,7 +119,7 @@ module Branchproof
                 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,
+                analysis: @analysis, minima: @minima, metrics: metrics,
                 diagnostics: @diagnostics, completeness: completeness,
                 run_metadata: @run_metadata)
     end
@@ -103,6 +140,7 @@ module Branchproof
                "Observations: #{metrics[:completed]} completed, #{metrics[:aborted]} aborted, " \
                "#{metrics[:unattributed]} unattributed",
                "Values: T=true, F=false, -=short-circuited"]
+      lines.concat(coverage_ladder_lines)
       lines << missing_summary_line if @missing_only
       lines << "Scope: supported decisions and conditions"
       lines << ""
@@ -110,7 +148,7 @@ module Branchproof
       render_minima(lines) unless @missing_only
       unless @diagnostics.empty?
         lines << "Diagnostics:"
-        @diagnostics.each { |diagnostic| lines << "  - #{value(diagnostic, :message) || value(diagnostic, :code)}" }
+        @diagnostics.each { |diagnostic| lines << "  - #{diagnostic_message(diagnostic)}" }
       end
       lines.join("\n") << "\n"
     end
@@ -125,14 +163,16 @@ module Branchproof
       conditions_to_render(decision).each do |condition|
         result = condition_result(decision, condition)
         detail = condition_detail(decision, condition, result)
-        status = if @analysis.nil? || @level == 1
+        status = if @analysis.nil? || (@level == 1 && !coverage_available?)
                    "NOT CALCULATED"
                  else
                    value(result, :status) || "NOT_PROVEN"
                  end
         lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
         lines << "    #{status}#{detail}"
+        render_condition_coverage(lines, decision, condition, result) if @level >= 2 && coverage_available?
       end
+      render_decision_coverage(lines, decision) if coverage_available?
       vectors_to_render(decision).each do |vector|
         values = Array(value(vector, :values)).map do |item|
           if item.nil?
@@ -150,6 +190,64 @@ module Branchproof
       lines << ""
     end
 
+    def coverage_status_label(status)
+      { "covered" => "PASS", "partial" => "FAIL", "unexecuted" => "UNEXECUTED", "unsupported" => "EXCLUDED" }.fetch(
+        status.to_s.downcase, status.to_s.upcase
+      )
+    end
+
+    def render_decision_coverage(lines, decision)
+      decision_coverage = value(value(analysis_for(decision), :coverage), :decision)
+      all_coverage = value(analysis_for(decision), :coverage) || {}
+      statuses = [["D", :decision], ["C", :condition], ["C/D", :condition_decision],
+                  ["MC/DC", :mcdc]].filter_map do |label, key|
+        row = value(all_coverage, key)
+        status = value(row, :status)
+        status ? criterion_status_text(label, row) : nil
+      end
+      lines << "  Coverage: #{statuses.join(", ")}" unless statuses.empty?
+      coverage = decision_coverage
+      return unless coverage
+
+      return unless @level >= 2
+
+      Array(value(coverage, :outcomes)).each do |outcome|
+        value_label = value(outcome, :value) ? "true" : "false"
+        owners = Array(value(outcome, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(outcome, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        lines << "  Outcome #{value_label}: #{value(outcome, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_outcomes))
+      return if missing.empty?
+
+      lines << "  Missing decision outcomes: #{missing.map do |item|
+        item ? "true" : "false"
+      end.join(", ")}"
+    end
+
+    def render_condition_coverage(lines, _decision, condition, result)
+      coverage = value(result, :coverage)
+      return unless coverage
+
+      values = Array(value(coverage, :values))
+      return if values.empty?
+
+      values.each do |entry|
+        value_label = value(entry, :value) ? "true" : "false"
+        owners = Array(value(entry, :test_ids)).map { |id| test_label(id) }
+        owners << "unattributed" if value(entry, :unattributed_count).to_i.positive?
+        evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
+        lines << "    Value #{value_label}: #{value(entry, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+      end
+      missing = Array(value(coverage, :missing_values))
+      return if missing.empty?
+
+      lines << "    Missing values for #{value(condition, :expression)}: #{missing.map do |item|
+        item ? "true" : "false"
+      end.join(", ")}"
+    end
+
     def render_minima(lines)
       rows = Array(@minima).map do |minimum|
         objective = value(minimum, :objective)
@@ -177,19 +275,19 @@ module Branchproof
     end
 
     def terminal_coverage_label
-      return "not calculated" if @analysis.nil? || @level == 1
+      return "not calculated" if @analysis.nil?
 
       coverage_label
     end
 
     def terminal_coverage_line
-      return "MC/DC: not calculated" if @analysis.nil? || @level == 1
+      return "MC/DC: not calculated" if @analysis.nil?
 
       "MC/DC: #{terminal_coverage_label} (#{metrics[:proven]}/#{metrics[:eligible_conditions]} conditions proven)"
     end
 
     def terminal_analysis_status
-      return "NOT CALCULATED" if @analysis.nil? || @level == 1
+      return "NOT CALCULATED" if @analysis.nil?
 
       analysis_status
     end
@@ -461,7 +559,7 @@ module Branchproof
     end
 
     def valid_for_requested_level?
-      return completeness[:observation] && completeness[:attribution] if @level == 1
+      return completeness[:observation] && completeness[:attribution] if @level == 1 && @analysis.nil?
 
       completeness.values.all? { |item| item == true }
     end
@@ -474,13 +572,14 @@ module Branchproof
     end
 
     def analysis_status
-      return "NOT_REQUESTED" if @analysis.nil? || @level == 1
+      return "NOT_REQUESTED" if @analysis.nil?
 
       valid_for_requested_level? ? "COMPLETE" : "PARTIAL"
     end
 
     def incomplete?
-      !completeness[:observation] || !completeness[:attribution] || (@level > 1 && !completeness[:analysis])
+      !completeness[:observation] || !completeness[:attribution] ||
+        (analysis_available? && !completeness[:analysis])
     end
 
     def vectors_for(decision)
@@ -512,7 +611,65 @@ module Branchproof
     end
 
     def analysis_available?
-      !@analysis.nil? && @level > 1
+      !@analysis.nil?
+    end
+
+    def coverage_available?
+      analysis_available? && !value(@analysis, :coverage).nil?
+    end
+
+    # Render the shared ladder in every terminal view.
+    def coverage_ladder_lines
+      return [] unless coverage_available?
+
+      aggregate = value(@analysis, :coverage) || {}
+      rows = [["D", :decision, :covered_decisions, :supported_decisions],
+              ["C", :condition, :covered_values, :required_values],
+              ["C/D", :condition_decision, :covered_decisions, :supported_decisions],
+              ["MC/DC", :mcdc, :proven_conditions, :supported_conditions]]
+      lines = ["Coverage ladder:"]
+      rows.each do |label, key, numerator_key, denominator_key|
+        row = value(aggregate, key)
+        next unless row
+
+        percentage = value(row, :percentage)
+        numerator = value(row, numerator_key) || 0
+        denominator = value(row, denominator_key) || 0
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        denominator_label = if ["D", "C/D"].include?(label)
+                              "decisions"
+                            else
+                              label == "C" ? "truth values" : "conditions"
+                            end
+        qualifier = incomplete? ? " (lower bound)" : ""
+        description = case label
+                      when "D" then "Decision coverage"
+                      when "C" then "Condition coverage"
+                      when "C/D" then "Condition/decision coverage"
+                      else "MC/DC coverage"
+                      end
+        lines << "  #{label} (#{description}): #{shown} (#{numerator}/#{denominator} #{denominator_label})#{qualifier}"
+      end
+      lines << ""
+      lines
+    end
+
+    def criterion_status_text(label, row)
+      raw_status = value(row, :status).to_s.downcase
+      status = coverage_status_label(raw_status)
+      return "#{label}=#{status}" if raw_status == "unsupported"
+
+      case label
+      when "D"
+        "#{label}=#{status} (#{value(row, :covered_outcomes) || 0}/#{value(row, :required_outcomes) || 0} outcomes)"
+      when "C"
+        "#{label}=#{status} (#{value(row, :covered_values) || 0}/#{value(row, :required_values) || 0} values; " \
+        "#{value(row, :covered_conditions) || 0}/#{value(row, :condition_count) || 0} conditions fully covered)"
+      when "MC/DC"
+        "#{label}=#{status} (#{value(row, :proven_conditions) || 0}/#{value(row, :condition_count) || 0} conditions)"
+      else
+        "#{label}=#{status}"
+      end
     end
 
     def analysis_complete?
@@ -592,5 +749,6 @@ module Branchproof
     def normalize_unknown(object)
       object.to_s
     end
+    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label
   end
 end

data/lib/branchproof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Branchproof
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/sig/branchproof.rbs

@@ -105,6 +105,7 @@ module Branchproof
     CRITERION_VERSION: String
     def initialize: (inventory: document, evidence: document, analysis: document?, minima: Array[document], baseline: document, diagnostics: Array[document], ?level: Integer, ?missing_only: bool, ?view: Symbol, ?run_metadata: document, ?saved_document: document?) -> void
     def self.from_document: (document: document, ?level: Integer?, ?view: Symbol, ?missing_only: bool) -> Report
+    def diagnostic_message: (Hash[Symbol | String, untyped] diagnostic) -> String
     def condition_explanation: (decision_id: String, condition_id: String) -> String
     def write: (io: _WriteIO, format: Symbol | String) -> nil
     def exit_code: () -> Integer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: branchproof
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Lucian Ghinda