rail_verdict 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62a7032233c6c05db93caede4d2fad10181a04aff006780106e92b474fe18195
-  data.tar.gz: 5a87a7f930f2bf519561404be6fbcec92c41c2596216beaf06ab0aa7a84fd01c
+  metadata.gz: 808405ac6448a462283966840c5b9074afff5cd43f0c2c3b477d9951e7dfe0a8
+  data.tar.gz: 2f3aa97c547c6db980c284ca4081bc09230d4e13f63369cced690f60d18ccddd
 SHA512:
-  metadata.gz: cbac4c960c4c1392d957ba96dc63776b7406a6da4f7f596735ea3635294dab6f99e94a5a99f022437bff51396354f8ba59ff4cab9f9abc7a5ce52ca0e60a4cf2
-  data.tar.gz: f83c03803134e56beb991545bb2dd1ddc8f43bb5beb821c2540161af623c34005389ccd04d4589944b738996442f30ab82be237a1ba9d832318760ca99d8a139
+  metadata.gz: a70e6b7d070e6d4990b0b7991af2332c572e0ad2c9438b0ada3afb7e095729285b5b5714c8be8be512e1c7d8907e089bec08d5e4b62524a401719d215bc2eb28
+  data.tar.gz: 6881881853b9073e8add4c6946d1bdb0da79928a57b6d27a057e9b1646dcbe9e960a9f646c9fb9f62743f5ba3c0d61f93fc2a1fa572b529e8071268f97b69f0b

data/README.md

@@ -182,6 +182,9 @@ railverdict check
 
 # 5. Inspect normalized findings
 railverdict findings
+
+# 6. Summarize one pull-request change from a single verification run
+railverdict pr --base origin/main
 ```
 
 ### Example: A Passing Gate
@@ -277,6 +280,53 @@ railverdict check --changed --base HEAD~1
 railverdict check --changed --base origin/main --format json
 ```
 
+### PR Intelligence
+
+`railverdict pr --base origin/main` produces a deterministic, versioned summary
+of the change, quality delta, objective Rails path signals, analyzer evidence,
+test metrics, and coverage available from that same verification run. Use
+`--format json` for machine consumers. Signals are deterministic attention
+indicators, not risk probabilities; `GateResult` and policy remain the only
+verification authority.
+
+Example console output:
+
+```
+RailVerdict PR Intelligence
+
+Gate: PASS
+Completion: complete
+Revision: 3f4a2c1d9e00 (base 8a7b6c5d4e33)
+
+Change
+  4 files
+  +38 / -7
+  added 1  modified 2  deleted 0  renamed 1
+
+Quality Delta
+  introduced 0  resolved 2  existing 8
+
+Signals
+  Database       YES
+  Authorization  YES
+  Routes         NO
+  Dependencies   NO
+  Configuration  NO
+  Tests          YES
+
+Evidence
+  rubocop: succeeded
+  rspec: succeeded
+```
+
+The JSON contract is [`pr-intelligence-v1.schema.json`](schemas/pr-intelligence-v1.schema.json).
+It includes `head`, `base`, `merge_base`, and configuration-digest provenance,
+plus a stable projection of the canonical `gate_result` without checkout-local
+paths. Without a compatible baseline, `quality_delta.available` is
+`false` with `reason: "baseline_not_available"`; it does not emit fake zeroes.
+Invalid Git bases and incomplete required evidence remain `INCOMPLETE` with
+exit code `2`.
+
 ### Key Capabilities
 
 - **Merge-Base Resolution:** Computes the exact `merge-base` between `HEAD` and the target branch;

data/lib/rail_verdict/cli.rb

@@ -20,6 +20,7 @@ module RailVerdict
         init             Write the default .railverdict.yml configuration
         doctor           Report configuration and analyzer observations
         check            Run verification and print the gate result
+        pr               Summarize one changed-scope verification for review
         baseline create  Deferred boundary; Phase 3 owns baseline writes
         findings         Print normalized findings from the evidence run
         explain          Explain a finding with optional AI
@@ -53,6 +54,8 @@ module RailVerdict
         command_doctor(argv.drop(1))
       when "check"
         command_check(argv.drop(1))
+      when "pr"
+        command_pr(argv.drop(1))
       when "baseline"
         command_baseline(argv.drop(1))
       when "findings"
@@ -144,6 +147,38 @@ module RailVerdict
       exit_code_for(outcome.result, interrupted: interrupted)
     end
 
+    def command_pr(argv)
+      options = { config: DEFAULT_CONFIG_PATH, format: "console", base: nil, baseline: nil, waiver: nil }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: railverdict pr [--config PATH] [--format console|json] [--base REV] [--baseline PATH] [--waiver PATH]"
+        opts.on("--config PATH", String) { |value| options[:config] = value }
+        opts.on("--format FORMAT", String) { |value| options[:format] = value }
+        opts.on("--base REV", String) { |value| options[:base] = value }
+        opts.on("--baseline PATH", String) { |value| options[:baseline] = value }
+        opts.on("--waiver PATH", String) { |value| options[:waiver] = value }
+      end
+      parse!(parser, argv)
+      unless %w[console json].include?(options[:format])
+        raise RailVerdict::UsageError, "invalid --format #{options[:format].inspect}; expected console or json"
+      end
+
+      outcome, interrupted = execute_check(options.merge(changed: true))
+      document = PRIntelligence.document(outcome)
+      if options[:format] == "json"
+        @stdout.write(JSON.generate(document) + "\n")
+      else
+        @stdout.write(Reporters::PRIntelligence.render(document))
+      end
+      exit_code_for(outcome.result, interrupted: interrupted)
+    rescue RailVerdict::UsageError => error
+      @stderr.puts "railverdict pr: #{error.message}"
+      @stderr.puts USAGE
+      EXIT_NO_GATE
+    rescue RailVerdict::Error => error
+      @stderr.puts "railverdict pr: #{error.message}"
+      EXIT_NO_GATE
+    end
+
     def command_baseline(argv)
       subcommand = argv.first
       raise RailVerdict::UsageError, "unknown baseline subcommand: #{subcommand.inspect}; only `baseline create` exists" unless subcommand == "create"

data/lib/rail_verdict/git/context.rb

@@ -6,21 +6,32 @@ require "pathname"
 module RailVerdict
   module Git
     class ChangedFile
-      attr_reader :status, :path, :old_path, :new_path, :score
+      attr_reader :status, :path, :old_path, :new_path, :score, :lines_added, :lines_removed
       attr_accessor :binary
 
-      def initialize(status:, path:, old_path:, new_path:, score:, binary: false)
+      def initialize(status:, path:, old_path:, new_path:, score:, binary: false, lines_added: nil, lines_removed: nil)
         @status = status
         @path = path
         @old_path = old_path
         @new_path = new_path
         @score = score
         @binary = binary
+        @lines_added = lines_added
+        @lines_removed = lines_removed
         freeze
       end
 
       def to_h
-        { "status" => status.to_s, "path" => path, "old_path" => old_path, "new_path" => new_path, "score" => score, "binary" => binary }
+        {
+          "status" => status.to_s,
+          "path" => path,
+          "old_path" => old_path,
+          "new_path" => new_path,
+          "score" => score,
+          "binary" => binary,
+          "lines_added" => lines_added,
+          "lines_removed" => lines_removed
+        }
       end
     end
 
@@ -236,11 +247,19 @@ module RailVerdict
           info = numstat[key] if key
           is_binary = !!(info && info[:binary])
           binary_set.add(key) if is_binary
-          ChangedFile.new(status: file.status, path: file.path, old_path: file.old_path, new_path: file.new_path, score: file.score, binary: is_binary)
+          ChangedFile.new(
+            status: file.status,
+            path: file.path,
+            old_path: file.old_path,
+            new_path: file.new_path,
+            score: file.score,
+            binary: is_binary,
+            lines_added: info && info[:added],
+            lines_removed: info && info[:deleted]
+          )
         end
 
-        changed = enriched.reject { |file| file.status == :deleted }.sort_by { |file| file.path.to_s }
-        [changed, binary_set]
+        [enriched.sort_by { |file| (file.path || file.old_path).to_s }, binary_set]
       end
       private_class_method :resolve_changed_files
 

data/lib/rail_verdict/git/diff_parser.rb

@@ -62,7 +62,7 @@ module RailVerdict
         parts.each do |entry|
           next if entry.empty?
 
-          fields = entry.split("\t")
+          fields = entry.split("\t", 3)
           next unless fields.length == 3
 
           added, deleted, path = fields
@@ -78,15 +78,27 @@ module RailVerdict
         parts = raw.split("\0")
         parts.pop if parts.last == ""
         result = {}
-        parts.each do |entry|
+        index = 0
+        while index < parts.length
+          entry = parts[index]
+          index += 1
           next if entry.empty?
 
-          fields = entry.split("\t")
-          next unless fields.length >= 3
+          fields = entry.split("\t", 3)
+          next unless fields.length >= 2
 
           added, deleted = fields[0], fields[1]
           binary = added == "-" || deleted == "-"
-          path = fields.length == 4 ? fields[3] : fields[2]
+          if fields.length >= 3 && !fields[2].empty?
+            path = fields[2]
+          else
+            old_path = parts[index]
+            new_path = parts[index + 1]
+            break if old_path.nil? || new_path.nil?
+
+            path = new_path
+            index += 2
+          end
           key = normalize_path(path)
           result[key] = { added: binary ? nil : added.to_i, deleted: binary ? nil : deleted.to_i, binary: binary }
         end

data/lib/rail_verdict/pr_intelligence.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailVerdict
+  module PRIntelligence
+    SCHEMA_VERSION = "1.0"
+    MAX_SIGNAL_EVIDENCE = 20
+    SIGNALS = {
+      "database_change" => lambda { |path| path == "db/schema.rb" || path == "db/structure.sql" || path.start_with?("db/migrate/") },
+      "routes_change" => lambda { |path| path == "config/routes.rb" || path.start_with?("config/routes/") },
+      "dependency_change" => lambda { |path| %w[Gemfile Gemfile.lock].include?(path) },
+      "configuration_change" => lambda { |path| path == "config" || path.start_with?("config/") },
+      "authorization_change" => lambda { |path| path.start_with?("app/policies/") },
+      "tests_change" => lambda { |path| path.start_with?("spec/") || path.start_with?("test/") }
+    }.freeze
+    STATUS_KEYS = %w[added modified deleted renamed].freeze
+    TEST_KEYS = %w[tests_total assertions failures errors skips duration_seconds seed runner].freeze
+    GATE_RESULT_KEYS = %w[
+      schema_version completion_status gate policy_status findings
+      operational_failures decision_reasons
+    ].freeze
+
+    module_function
+
+    def document(outcome)
+      result = outcome.result
+      git_context = outcome.context&.git_context
+      git = result.git || {}
+
+      document = {
+        "schema_version" => SCHEMA_VERSION,
+        "provenance" => provenance(outcome, git_context, git),
+        "gate_result" => gate_result(result),
+        "change" => change(git_context),
+        "signals" => signals(git_context),
+        "quality_delta" => quality_delta(result),
+        "analyzer_evidence" => analyzer_evidence(result),
+        "test_intelligence" => test_intelligence(result),
+        "coverage" => coverage(result)
+      }
+      errors = SchemaValidator.validate_pr_intelligence(document)
+      raise RailVerdict::Error, "pr-intelligence-v1 validation failed: #{errors.join('; ')}" unless errors.empty?
+
+      document
+    end
+
+    def render_json(outcome)
+      JSON.generate(document(outcome)) + "\n"
+    end
+
+    def provenance(outcome, git_context, git)
+      context = outcome.context
+      {
+        "head" => git_context&.head || git["head"],
+        "base" => git_context&.base || git["base"],
+        "merge_base" => git_context&.merge_base || git["merge_base"],
+        "configuration_digest" => context&.configuration_digest
+      }
+    end
+    private_class_method :provenance
+
+    def gate_result(result)
+      source = result.to_schema_h
+      GATE_RESULT_KEYS.to_h { |key| [key, source.fetch(key)] }
+    end
+    private_class_method :gate_result
+
+    def change(git_context)
+      return { "available" => false, "reason" => "git_scope_unavailable" } unless git_context
+
+      files = git_context.changed_files
+      lines_added = line_total(files, :lines_added)
+      lines_removed = line_total(files, :lines_removed)
+      status_counts = STATUS_KEYS.to_h { |status| [status, files.count { |file| file.status.to_s == status }] }
+      {
+        "available" => true,
+        "files_changed" => files.length,
+        "lines_added" => lines_added,
+        "lines_removed" => lines_removed,
+        "status_counts" => status_counts
+      }
+    end
+    private_class_method :change
+
+    def line_total(files, attribute)
+      values = files.map { |file| file.public_send(attribute) }
+      return 0 if values.empty?
+      return nil unless values.all? { |value| value.is_a?(Integer) && value >= 0 }
+
+      values.sum
+    end
+    private_class_method :line_total
+
+    def signals(git_context)
+      paths = if git_context
+        git_context.changed_files.flat_map { |file| [file.path, file.old_path, file.new_path] }.compact.uniq.sort
+      else
+        []
+      end
+      available = !git_context.nil?
+
+      SIGNALS.to_h do |name, matcher|
+        evidence = available ? paths.select { |path| matcher.call(path) } : []
+        evidence_head = evidence.first(MAX_SIGNAL_EVIDENCE)
+        entry = {
+          "available" => available,
+          "present" => !evidence.empty?,
+          "evidence" => evidence_head,
+          "additional_evidence_count" => [evidence.length - evidence_head.length, 0].max
+        }
+        entry["reason"] = "git_scope_unavailable" unless available
+        [name, entry]
+      end
+    end
+    private_class_method :signals
+
+    def quality_delta(result)
+      comparison = result.comparison
+      baseline = result.baseline
+      unless baseline && baseline["loaded"] == true && comparison.is_a?(Hash)
+        return { "available" => false, "reason" => baseline && baseline["compatible"] == false ? "baseline_incompatible" : "baseline_not_available" }
+      end
+
+      counts = comparison.fetch("counts", {})
+      {
+        "available" => true,
+        "introduced" => counts.fetch("introduced", 0),
+        "existing" => counts.fetch("existing", 0),
+        "resolved" => counts.fetch("resolved", 0),
+        "changed" => counts.fetch("changed", 0),
+        "moved" => counts.fetch("moved", 0),
+        "waived" => counts.fetch("waived", 0),
+        "orphaned_waivers" => Array(comparison["orphaned_waivers"]).length
+      }
+    end
+    private_class_method :quality_delta
+
+    def analyzer_evidence(result)
+      result.analyzer_results.sort_by(&:analyzer).map do |analyzer|
+        entry = {
+          "analyzer" => analyzer.analyzer,
+          "execution_status" => analyzer.execution_status,
+          "evidence_status" => analyzer.evidence_status
+        }
+        entry["tool_version"] = analyzer.tool_version if analyzer.tool_version
+        entry
+      end
+    end
+    private_class_method :analyzer_evidence
+
+    def test_intelligence(result)
+      analyzers = {}
+      result.analyzer_results.sort_by(&:analyzer).each do |analyzer|
+        next unless %w[minitest rspec].include?(analyzer.analyzer)
+        next unless analyzer.execution_status == "succeeded" && analyzer.evidence_summary.is_a?(Hash)
+
+        summary = analyzer.evidence_summary
+        analyzers[analyzer.analyzer] = TEST_KEYS.each_with_object({}) do |key, values|
+          values[key] = summary[key] if summary.key?(key)
+        end
+      end
+      return { "available" => false, "reason" => "test_metrics_unavailable" } if analyzers.empty?
+
+      { "available" => true, "analyzers" => analyzers }
+    end
+    private_class_method :test_intelligence
+
+    def coverage(result)
+      analyzer = result.analyzer_results.find { |item| item.analyzer == "simplecov" }
+      summary = analyzer&.evidence_summary
+      unless analyzer&.execution_status == "succeeded" && summary.is_a?(Hash)
+        return { "available" => false, "reason" => "coverage_evidence_unavailable" }
+      end
+
+      output = { "available" => true }
+      output["global_percent"] = summary["percent"] if summary["percent"].is_a?(Numeric)
+      changed = summary["changed_line_coverage"]
+      if changed.is_a?(Hash) && changed["percent"].is_a?(Numeric)
+        output["changed_lines_percent"] = changed["percent"]
+        output["changed_lines_covered"] = changed["covered_lines"] if changed["covered_lines"].is_a?(Integer)
+        output["changed_lines_executable"] = changed["executable_lines"] if changed["executable_lines"].is_a?(Integer)
+      end
+      output
+    end
+    private_class_method :coverage
+  end
+end

data/lib/rail_verdict/reporters/pr_intelligence.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RailVerdict
+  module Reporters
+    module PRIntelligence
+      SIGNAL_LABELS = {
+        "database_change" => "Database",
+        "authorization_change" => "Authorization",
+        "routes_change" => "Routes",
+        "dependency_change" => "Dependencies",
+        "configuration_change" => "Configuration",
+        "tests_change" => "Tests"
+      }.freeze
+
+      module_function
+
+      def render(document)
+        gate_result = document.fetch("gate_result")
+        lines = ["RailVerdict PR Intelligence", "", "Gate: #{gate_result.fetch('gate')}", "Completion: #{gate_result.fetch('completion_status')}"]
+        provenance = document.fetch("provenance")
+        lines << "Revision: #{short(provenance['head'])} (base #{short(provenance['base'])})"
+
+        change = document.fetch("change")
+        lines << ""
+        lines << "Change"
+        if change["available"]
+          lines << "  #{change.fetch('files_changed')} files"
+          lines << "  +#{change['lines_added'] || '?'} / -#{change['lines_removed'] || '?'}"
+          counts = change.fetch("status_counts")
+          lines << "  added #{counts['added']}  modified #{counts['modified']}  deleted #{counts['deleted']}  renamed #{counts['renamed']}"
+        else
+          lines << "  unavailable (#{change.fetch('reason')})"
+        end
+
+        delta = document.fetch("quality_delta")
+        lines << ""
+        lines << "Quality Delta"
+        if delta["available"]
+          lines << "  introduced #{delta['introduced']}  resolved #{delta['resolved']}  existing #{delta['existing']}"
+          lines << "  changed #{delta['changed']}  moved #{delta['moved']}  waived #{delta['waived']}  orphaned waivers #{delta['orphaned_waivers']}"
+        else
+          lines << "  unavailable (#{delta.fetch('reason')})"
+        end
+
+        lines << ""
+        lines << "Signals"
+        document.fetch("signals").each do |name, signal|
+          label = SIGNAL_LABELS.fetch(name, name)
+          value = signal["available"] ? (signal["present"] ? "YES" : "NO") : "N/A"
+          lines << format("  %-14s %s", label, value)
+        end
+
+        lines << ""
+        lines << "Evidence"
+        evidence = document.fetch("analyzer_evidence")
+        if evidence.empty?
+          lines << "  none"
+        else
+          evidence.each { |entry| lines << "  #{entry.fetch('analyzer')}: #{entry.fetch('execution_status')}" }
+        end
+
+        tests = document.fetch("test_intelligence")
+        lines << ""
+        lines << "Tests: #{tests['available'] ? tests.fetch('analyzers').map { |name, summary| "#{name} #{summary['tests_total']} total, #{summary['failures']} failures" }.join('; ') : tests.fetch('reason')}"
+        coverage = document.fetch("coverage")
+        coverage_text = if coverage["available"]
+          parts = []
+          parts << "global #{coverage['global_percent']}%" if coverage.key?("global_percent")
+          parts << "changed #{coverage['changed_lines_percent']}%" if coverage.key?("changed_lines_percent")
+          parts.join(", ")
+        else
+          coverage.fetch("reason")
+        end
+        lines << "Coverage: #{coverage_text}"
+        lines.join("\n") + "\n"
+      end
+
+      def short(value)
+        value ? value.to_s[0, 12] : "unknown"
+      end
+      private_class_method :short
+    end
+  end
+end

data/lib/rail_verdict/schema_validator.rb

@@ -18,6 +18,7 @@ module RailVerdict
     WAIVER_SCHEMA = "waiver-v1.schema.json"
     WAIVERS_SCHEMA = "waivers-v1.schema.json"
     REPAIR_PACKET_SCHEMA = "repair-packet-v1.schema.json"
+    PR_INTELLIGENCE_SCHEMA = "pr-intelligence-v1.schema.json"
 
     def self.schema_dir
       File.expand_path("../../schemas", __dir__)
@@ -68,6 +69,10 @@ module RailVerdict
       validate(data, REPAIR_PACKET_SCHEMA)
     end
 
+    def self.validate_pr_intelligence(data)
+      validate(data, PR_INTELLIGENCE_SCHEMA)
+    end
+
     def self.validate(data, schema_name)
       schema = load_schema(schema_name)
       JSONSchemer.schema(schema).validate(data).map { |error| format_error(error) }

data/lib/rail_verdict/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailVerdict
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/rail_verdict.rb

@@ -36,6 +36,8 @@ require_relative "rail_verdict/reporters/console"
 require_relative "rail_verdict/reporters/json_reporter"
 require_relative "rail_verdict/reporters/sarif"
 require_relative "rail_verdict/reporters/github_annotations"
+require_relative "rail_verdict/reporters/pr_intelligence"
+require_relative "rail_verdict/pr_intelligence"
 require_relative "rail_verdict/cli"
 require_relative "rail_verdict/intelligence"
 require_relative "rail_verdict/intelligence/source_reader"

data/schemas/pr-intelligence-v1.schema.json

@@ -0,0 +1,285 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://railverdict.dev/schemas/pr-intelligence/v1.schema.json",
+  "title": "RailVerdict PR Intelligence v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version",
+    "provenance",
+    "gate_result",
+    "change",
+    "signals",
+    "quality_delta",
+    "analyzer_evidence",
+    "test_intelligence",
+    "coverage"
+  ],
+  "properties": {
+    "schema_version": { "const": "1.0" },
+    "provenance": { "$ref": "#/$defs/provenance" },
+    "gate_result": { "$ref": "#/$defs/gate_result" },
+    "change": { "$ref": "#/$defs/change" },
+    "signals": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "database_change",
+        "routes_change",
+        "dependency_change",
+        "configuration_change",
+        "authorization_change",
+        "tests_change"
+      ],
+      "properties": {
+        "database_change": { "$ref": "#/$defs/signal" },
+        "routes_change": { "$ref": "#/$defs/signal" },
+        "dependency_change": { "$ref": "#/$defs/signal" },
+        "configuration_change": { "$ref": "#/$defs/signal" },
+        "authorization_change": { "$ref": "#/$defs/signal" },
+        "tests_change": { "$ref": "#/$defs/signal" }
+      }
+    },
+    "quality_delta": { "$ref": "#/$defs/quality_delta" },
+    "analyzer_evidence": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/analyzer_evidence" }
+    },
+    "test_intelligence": { "$ref": "#/$defs/test_intelligence" },
+    "coverage": { "$ref": "#/$defs/coverage" }
+  },
+  "$defs": {
+    "nullable_string": { "type": ["string", "null"] },
+    "provenance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["head", "base", "merge_base", "configuration_digest"],
+      "properties": {
+        "head": { "$ref": "#/$defs/nullable_string" },
+        "base": { "$ref": "#/$defs/nullable_string" },
+        "merge_base": { "$ref": "#/$defs/nullable_string" },
+        "configuration_digest": { "$ref": "#/$defs/nullable_string" }
+      }
+    },
+    "change": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["available"],
+      "properties": {
+        "available": { "type": "boolean" },
+        "reason": { "type": "string" },
+        "files_changed": { "type": "integer", "minimum": 0 },
+        "lines_added": { "type": ["integer", "null"], "minimum": 0 },
+        "lines_removed": { "type": ["integer", "null"], "minimum": 0 },
+        "status_counts": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["added", "modified", "deleted", "renamed"],
+          "properties": {
+            "added": { "type": "integer", "minimum": 0 },
+            "modified": { "type": "integer", "minimum": 0 },
+            "deleted": { "type": "integer", "minimum": 0 },
+            "renamed": { "type": "integer", "minimum": 0 }
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "available": { "const": true } } },
+          "then": { "required": ["files_changed", "lines_added", "lines_removed", "status_counts"] }
+        },
+        {
+          "if": { "properties": { "available": { "const": false } } },
+          "then": { "required": ["reason"] }
+        }
+      ]
+    },
+    "signal": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["available", "present", "evidence", "additional_evidence_count"],
+      "properties": {
+        "available": { "type": "boolean" },
+        "present": { "type": "boolean" },
+        "evidence": {
+          "type": "array",
+          "maxItems": 20,
+          "items": { "type": "string", "minLength": 1 }
+        },
+        "additional_evidence_count": { "type": "integer", "minimum": 0 },
+        "reason": { "type": "string" }
+      }
+    },
+    "quality_delta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["available"],
+      "properties": {
+        "available": { "type": "boolean" },
+        "reason": { "type": "string" },
+        "introduced": { "type": "integer", "minimum": 0 },
+        "existing": { "type": "integer", "minimum": 0 },
+        "resolved": { "type": "integer", "minimum": 0 },
+        "changed": { "type": "integer", "minimum": 0 },
+        "moved": { "type": "integer", "minimum": 0 },
+        "waived": { "type": "integer", "minimum": 0 },
+        "orphaned_waivers": { "type": "integer", "minimum": 0 }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "available": { "const": true } } },
+          "then": { "required": ["introduced", "existing", "resolved", "changed", "moved", "waived", "orphaned_waivers"] }
+        },
+        {
+          "if": { "properties": { "available": { "const": false } } },
+          "then": { "required": ["reason"] }
+        }
+      ]
+    },
+    "analyzer_evidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["analyzer", "execution_status", "evidence_status"],
+      "properties": {
+        "analyzer": { "type": "string", "minLength": 1 },
+        "tool_version": { "type": "string", "minLength": 1 },
+        "execution_status": { "type": "string", "minLength": 1 },
+        "evidence_status": { "enum": ["complete", "incomplete"] }
+      }
+    },
+    "gate_result": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schema_version",
+        "completion_status",
+        "gate",
+        "policy_status",
+        "findings",
+        "operational_failures",
+        "decision_reasons"
+      ],
+      "properties": {
+        "schema_version": { "const": "1.0" },
+        "completion_status": { "enum": ["complete", "incomplete", "interrupted"] },
+        "gate": { "enum": ["PASS", "WARN", "FAIL", "INCOMPLETE"] },
+        "policy_status": { "enum": ["pass", "warn", "fail", "not_evaluated"] },
+        "findings": { "type": "array", "items": { "$ref": "#/$defs/finding_summary" } },
+        "operational_failures": { "type": "array", "items": { "$ref": "#/$defs/operational_failure" } },
+        "decision_reasons": { "type": "array", "items": { "$ref": "#/$defs/decision_reason" } }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "completion_status": { "const": "complete" } } },
+          "then": {
+            "properties": {
+              "gate": { "enum": ["PASS", "WARN", "FAIL"] },
+              "policy_status": { "enum": ["pass", "warn", "fail"] }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "completion_status": { "enum": ["incomplete", "interrupted"] } } },
+          "then": {
+            "properties": {
+              "gate": { "const": "INCOMPLETE" },
+              "policy_status": { "const": "not_evaluated" },
+              "operational_failures": { "minItems": 1 }
+            }
+          }
+        }
+      ]
+    },
+    "finding_summary": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "fingerprint", "severity", "state", "blocking"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "fingerprint": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+        "severity": { "enum": ["info", "low", "medium", "high", "critical"] },
+        "state": { "enum": ["observed", "introduced", "existing", "resolved", "changed", "moved", "suppressed", "waived"] },
+        "blocking": { "type": "boolean" }
+      }
+    },
+    "operational_failure": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": { "enum": ["unavailable", "unsupported", "timed_out", "signaled", "failed", "parse_failed", "truncated", "malformed", "configuration", "interrupted", "incomplete_evidence"] },
+        "analyzer": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "message": { "type": "string", "minLength": 1, "maxLength": 4096 }
+      }
+    },
+    "decision_reason": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "message": { "type": "string", "minLength": 1, "maxLength": 4096 }
+      }
+    },
+    "test_intelligence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["available"],
+      "properties": {
+        "available": { "type": "boolean" },
+        "reason": { "type": "string", "minLength": 1 },
+        "analyzers": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "minitest": { "$ref": "#/$defs/test_summary" },
+            "rspec": { "$ref": "#/$defs/test_summary" }
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "available": { "const": true } } },
+          "then": { "required": ["analyzers"] }
+        },
+        {
+          "if": { "properties": { "available": { "const": false } } },
+          "then": { "required": ["reason"] }
+        }
+      ]
+    },
+    "test_summary": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "tests_total": { "type": "integer", "minimum": 0 },
+        "assertions": { "type": "integer", "minimum": 0 },
+        "failures": { "type": "integer", "minimum": 0 },
+        "errors": { "type": "integer", "minimum": 0 },
+        "skips": { "type": "integer", "minimum": 0 },
+        "duration_seconds": { "type": "number", "minimum": 0 },
+        "seed": { "type": ["integer", "null"] },
+        "runner": { "type": "string", "minLength": 1, "maxLength": 128 }
+      }
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["available"],
+      "properties": {
+        "available": { "type": "boolean" },
+        "reason": { "type": "string", "minLength": 1 },
+        "global_percent": { "type": "number", "minimum": 0, "maximum": 100 },
+        "changed_lines_percent": { "type": "number", "minimum": 0, "maximum": 100 },
+        "changed_lines_covered": { "type": "integer", "minimum": 0 },
+        "changed_lines_executable": { "type": "integer", "minimum": 0 }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "available": { "const": false } } },
+          "then": { "required": ["reason"] }
+        }
+      ]
+    }
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rail_verdict
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Pedro Dalben
@@ -113,6 +113,7 @@ files:
 - lib/rail_verdict/mcp/tools/verify.rb
 - lib/rail_verdict/mcp/tools/verify_repair.rb
 - lib/rail_verdict/mcp/validators.rb
+- lib/rail_verdict/pr_intelligence.rb
 - lib/rail_verdict/process_runner.rb
 - lib/rail_verdict/rails_context.rb
 - lib/rail_verdict/rails_context/classifier.rb
@@ -141,6 +142,7 @@ files:
 - lib/rail_verdict/reporters/console.rb
 - lib/rail_verdict/reporters/github_annotations.rb
 - lib/rail_verdict/reporters/json_reporter.rb
+- lib/rail_verdict/reporters/pr_intelligence.rb
 - lib/rail_verdict/reporters/sarif.rb
 - lib/rail_verdict/run_context.rb
 - lib/rail_verdict/schema_validator.rb
@@ -160,6 +162,7 @@ files:
 - schemas/coverage-v1.schema.json
 - schemas/finding-v1.schema.json
 - schemas/minitest-reporter-v1.schema.json
+- schemas/pr-intelligence-v1.schema.json
 - schemas/repair-packet-v1.schema.json
 - schemas/result-v1.schema.json
 - schemas/waiver-v1.schema.json