aireview 2.1.0 → 2.2.0

data/lib/aireview/model_candidate.rb

@@ -1,19 +1,48 @@
 # frozen_string_literal: true
+require_relative 'errors'
 
 module Aireview
-  KNOWN_PROVIDERS = %w[gemini ollama].freeze
+  # Providers a "provider/name" string may start with. An OpenRouter name
+  # carries a slash of its own, so in a string it always goes with the
+  # prefix: openrouter/anthropic/claude-sonnet-4.5.
+  KNOWN_PROVIDERS = %w[gemini ollama openai anthropic openrouter].freeze
 
-  # A model in a stage chain: provider, name and request size limit.
-  # Compared by provider and name — the limit depends on the stage.
-  ModelCandidate = Struct.new(:provider, :model, :max_prompt_chars, keyword_init: true) do
+  # A model in a stage chain: provider, name, request size limit and, for a
+  # server of your own, its address. Compared by provider, name and address
+  # — the limit depends on the stage.
+  ModelCandidate = Struct.new(:provider, :model, :max_prompt_chars, :api_base, keyword_init: true) do
+    # The address is part of the name, scheme included: two servers with the
+    # same model (http and https ones too) are two models for quarantine,
+    # reserves and the review key.
     def to_s
-      "#{provider}/#{model}"
+      name = "#{provider}/#{model}"
+      api_base ? "#{name}@#{api_base.chomp('/')}" : name
+    end
+
+    # Every way a start or a CLI override may name this model: bare,
+    # "provider/name", or the full name with the address. One list for the
+    # config check and for picking the model, so they cannot disagree.
+    def names
+      [model.to_s, "#{provider}/#{model}", to_s].uniq
     end
 
     def same_model?(other)
       to_s == other.to_s
     end
 
+    # Models sharing keys: a provider's own API, or one server of your own.
+    def key_source
+      api_base ? "#{provider}@#{api_base}" : provider.to_s
+    end
+
+    # api_base of a model or a stage: an http(s) address or nothing.
+    def self.api_base(value, name)
+      return nil if value.nil? || value.to_s.strip.empty?
+      return value.to_s.strip if value.to_s.strip.match?(%r{\Ahttps?://\S+\z})
+
+      raise ConfigError, "#{name} must be an http(s) URL, got #{value.inspect}"
+    end
+
     # A "provider/name" string or a bare name (the provider is separated by
     # a slash because Ollama tags contain a colon), or a hash with model.
     def self.parse_item(item)

data/lib/aireview/model_checker.rb

@@ -8,6 +8,7 @@ require_relative 'review_pipeline'
 require_relative 'result_parser'
 require_relative 'llm_client'
 require_relative 'output_schemas'
+require_relative 'jev_client'
 
 module Aireview
   # `aireview models check`: every model of both stage chains gets one
@@ -16,6 +17,10 @@ module Aireview
   # validation as in a run: the provider's catalog is not consulted, "the
   # model is listed" does not mean "our request with the schema passes on
   # it". No reserves, quarantine or walking — this is a check, not a review.
+  # Only the stages that need an LLM are checked (Jev with fallback: fail
+  # needs no LLM Critique); Jev gets a probe of its own when it is the
+  # critique engine, and in shadow mode too, but then its result is shown
+  # without counting: the shadow never blocks a release.
   class ModelChecker
     PROBE_MERGE_REQUEST = {
       'title' => 'Fix order total',
@@ -32,6 +37,10 @@ module Aireview
       }
     ].freeze
     PROBE_CANDIDATE_IDS = ['C1'].freeze
+    JEV_PROBE_STATE = 'The order total must include the quantity.'
+    JEV_PROBE_QUESTIONS = {
+      'mentions_quantity' => {'type' => 'noul', 'instructions' => 'Does the text mention a quantity?'}
+    }.freeze
     # ok and skipped do not block a release, everything else does. In strict
     # mode (a runner where Ollama must be running) skipped fails too.
     PASSING = %i[ok skipped].freeze
@@ -52,6 +61,7 @@ module Aireview
       @strict = strict
       client = dependencies[:client]
       sleeper = dependencies[:sleeper]
+      @jev_client = dependencies[:jev_client]
       @logger = logger
       @client = client || LlmClient.new(config: config, logger: logger)
       @sleeper = sleeper || ->(seconds) { sleep(seconds) }
@@ -63,13 +73,14 @@ module Aireview
     # 1 — at least one did not.
     def run
       @config.require_llm_configuration!
-      candidates = STAGES.flat_map { |stage| @config.stage_chain(stage) }.uniq(&:to_s)
+      stages = @config.llm_stages
+      candidates = stages.flat_map { |stage| @config.stage_chain(stage) }.uniq(&:to_s)
       prompts = probe_prompts
-      @out.puts("Checking #{candidates.size} model(s) with the generate and critique schemas")
+      @out.puts("Checking #{candidates.size} model(s) with the #{stages.join(' and ')} schemas")
       results = candidates.flat_map do |candidate|
-        STAGES.map { |stage| check(candidate, stage, prompts).tap { |result| @out.puts(result) } }
+        stages.map { |stage| check(candidate, stage, prompts).tap { |result| @out.puts(result) } }
       end
-      summary(results)
+      summary(results + jev_results)
     end
 
     private
@@ -110,10 +121,40 @@ module Aireview
         stage: stage, system: prompt[:system_prompt], user: prompt[:user_prompt], temperature: 0,
         schema: stage == 'critique' ? CritiqueOutputSchema : GenerateOutputSchema
       )
-      key = @config.provider_api_keys(candidate.provider).first
+      key = @config.candidate_api_keys(candidate).first
       LlmClient.content(@client.request(request, candidate: candidate, key: key, timeout: @config.llm_timeout.to_f))
     end
 
+    # The Jev probe counts only when Jev is the critique engine.
+    def jev_results
+      counted = @config.jev_critique?
+      return [] unless counted || @config.jev_shadow?
+
+      result = check_jev
+      result.detail = [result.detail, 'shadow only, not counted'].compact.join('; ') unless counted
+      @out.puts(result)
+      counted ? [result] : []
+    end
+
+    def check_jev
+      name = "jev/#{@config.jev_model}"
+      if Aireview::Utils.blank?(@config.jev_api_key)
+        return Result.new(candidate: name, stage: 'jev', status: :skipped, detail: 'JEV_API_KEY is not set')
+      end
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      jev_client.evaluate(state: JEV_PROBE_STATE, questions: JEV_PROBE_QUESTIONS)
+      Result.new(candidate: name, stage: 'jev', status: :ok,
+                 seconds: Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at)
+    rescue JevError => e
+      status = e.status.nil? || [429, 529].include?(e.status) ? :unverified : :failed
+      Result.new(candidate: name, stage: 'jev', status: status, detail: e.message)
+    end
+
+    def jev_client
+      @jev_client ||= JevClient.new(config: @config, logger: @logger)
+    end
+
     # missing — the provider has no such model; unverified — the provider
     # could not answer right now (overload, quota, timeout); skipped — Ollama
     # is not running where the check runs; failed — everything else.

data/lib/aireview/model_pool.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require_relative 'errors'
+require_relative 'stages'
 require_relative 'utils'
 require_relative 'model_candidate'
 require_relative 'stage_chains'
@@ -26,11 +27,24 @@ module Aireview
       return false if Aireview::Utils.blank?(model)
 
       Array(items).each_with_index.any? do |item, index|
-        parsed = parse_item(item, index, provider)
-        parsed[:model] == model.to_s || "#{parsed[:provider]}/#{parsed[:model]}" == model.to_s
+        names(parse_item(item, index, provider)).include?(model.to_s)
       end
     end
 
+    def self.item_candidate(item)
+      ModelCandidate.new(provider: item[:provider], model: item[:model], api_base: item[:api_base])
+    end
+
+    # The full name of a pool item, with the address of a server of your own.
+    def self.item_name(item)
+      item_candidate(item).to_s
+    end
+
+    # How a model may be named in a start or a CLI override (ModelCandidate#names).
+    def self.names(item)
+      item_candidate(item).names
+    end
+
     def self.parse_item(item, index, provider)
       item = ModelCandidate.parse_item(item)
       name = "llm.models[#{index}]"
@@ -41,7 +55,8 @@ module Aireview
       {
         provider: (item['provider'] || provider).to_s,
         model: item['model'].to_s,
-        max_prompt_chars: limit.nil? ? nil : StageChains.positive_limit(limit, name)
+        max_prompt_chars: limit.nil? ? nil : StageChains.positive_limit(limit, name),
+        api_base: ModelCandidate.api_base(item['api_base'], "#{name}.api_base")
       }
     end
 
@@ -50,30 +65,38 @@ module Aireview
     # the pool (image defaults versus the project's LLM_MODELS): such a start
     # missing from the pool is replaced by the first model with a warning,
     # an explicit start outside the pool is a configuration error;
-    # own_chains — stages with a chain of their own.
-    # Nine named settings read better than a struct for its own sake.
+    # own_chains — stages with a chain of their own; stages — the stages
+    # that go to an LLM in this run: without Critique (Jev decides with no
+    # fallback, --no-critique) the plan has no critique chain and no critique
+    # policy to validate or to sign.
+    # Ten named settings read better than a struct for its own sake.
     def initialize(items:, provider:, limits:, starts: {}, inherited_starts: [], rank: nil, allow_weaker: false, # rubocop:disable Metrics/ParameterLists
-                   own_chains: nil, only_primary: false)
+                   own_chains: nil, only_primary: false, stages: STAGES)
+      @stages = stages.map(&:to_s)
       @items = parse_items(items, provider)
       @limits = limits.transform_keys(&:to_s)
-      @rank = validate_rank(rank)
-      @allow_weaker = allow_weaker == true
+      @rank, @allow_weaker = critique_policy(rank, allow_weaker)
       @own_chains = own_chains || StageChains.new({})
       @only_primary = only_primary
       @warnings = []
       @starts = resolve_starts(starts.transform_keys(&:to_s), inherited_starts.map(&:to_s))
     end
 
+    def stage?(stage)
+      @stages.include?(stage.to_s)
+    end
+
     def pool(stage = 'generate')
       limit = @limits.fetch(stage.to_s)
       @items.map do |item|
         ModelCandidate.new(provider: item[:provider], model: item[:model],
-                           max_prompt_chars: item[:max_prompt_chars] || limit)
+                           max_prompt_chars: item[:max_prompt_chars] || limit, api_base: item[:api_base])
       end
     end
 
     def chain(stage)
       stage = stage.to_s
+      raise ArgumentError, "unknown LLM stage #{stage.inspect}" unless stage?(stage)
       return @own_chains.chain(stage) unless pool_stage?(stage)
 
       trim(pool(stage).rotate(index_of(@starts[stage] || @items.first[:model])))
@@ -107,21 +130,20 @@ module Aireview
 
     # The order and policy of the pool go into the review key: they decide
     # which model checks the findings. nil when a stage is outside the pool.
+    # Without Critique only the generate part: a critique setting nobody
+    # uses must not change the key, and the pool must stay in it.
     def signature
-      return nil unless both_stages_in_pool?
+      return nil unless all_stages_in_pool?
 
-      {
-        'models' => pool.map(&:to_s),
-        'generate_start' => @starts['generate'],
-        'critique_start' => @starts['critique'],
-        'rank' => @rank,
-        'allow_weaker' => @allow_weaker
-      }
+      signature = {'models' => pool.map(&:to_s), 'generate_start' => @starts['generate']}
+      return signature unless stage?('critique')
+
+      signature.merge('critique_start' => @starts['critique'], 'rank' => @rank, 'allow_weaker' => @allow_weaker)
     end
 
     # The critique selection rule in words, for --dry-run.
     def rule
-      return nil unless both_stages_in_pool?
+      return nil unless stage?('critique') && all_stages_in_pool?
       return @rank if @rank == 'any' || !@allow_weaker
 
       "#{@rank}, weaker allowed"
@@ -132,7 +154,7 @@ module Aireview
     end
 
     def pool_stage?(stage)
-      !@own_chains.stage?(stage)
+      stage?(stage) && !@own_chains.stage?(stage)
     end
 
     def pool_member?(model)
@@ -147,12 +169,12 @@ module Aireview
 
     private
 
-    def both_stages_in_pool?
-      STAGES.all? { |stage| pool_stage?(stage) }
+    def all_stages_in_pool?
+      @stages.all? { |stage| pool_stage?(stage) }
     end
 
     def rank_applies?(after)
-      both_stages_in_pool? && @rank != 'any' && pool_member?(after)
+      all_stages_in_pool? && @rank != 'any' && pool_member?(after)
     end
 
     def trim(chain)
@@ -174,7 +196,7 @@ module Aireview
 
     # The start of a stage with its own chain is not checked: it is outside the pool.
     def resolve_starts(starts, inherited)
-      STAGES.to_h do |stage|
+      @stages.to_h do |stage|
         start = starts[stage]
         next [stage, nil] if Aireview::Utils.blank?(start) || !pool_stage?(stage)
         next [stage, start] if pool_member?(start)
@@ -192,15 +214,22 @@ module Aireview
       raise ConfigError, "#{model} is not in llm.models: #{pool.join(', ')}"
     end
 
-    # A model is given by name or as "provider/name"; a candidate matches by provider and name.
+    # A model is given by name, as "provider/name" or by its full name; a
+    # candidate matches by provider, name and server address.
     def match?(item, model)
-      return "#{item[:provider]}/#{item[:model]}" == model.to_s if model.is_a?(ModelCandidate)
+      return self.class.item_name(item) == model.to_s if model.is_a?(ModelCandidate)
 
-      item[:model] == model.to_s || "#{item[:provider]}/#{item[:model]}" == model.to_s
+      self.class.names(item).include?(model.to_s)
     end
 
     def match_candidate?(candidate, model)
-      candidate.model == model.to_s || candidate.to_s == model.to_s
+      candidate.names.include?(model.to_s)
+    end
+
+    def critique_policy(rank, allow_weaker)
+      return [nil, false] unless stage?('critique')
+
+      [validate_rank(rank), allow_weaker == true]
     end
 
     def validate_rank(rank)
@@ -214,7 +243,7 @@ module Aireview
       parsed = Array(items).each_with_index.map { |item, index| self.class.parse_item(item, index, provider) }
       raise ConfigError, 'llm.models must not be empty' if parsed.empty?
 
-      names = parsed.map { |item| "#{item[:provider]}/#{item[:model]}" }
+      names = parsed.map { |item| self.class.item_name(item) }
       duplicates = names.tally.select { |_, count| count > 1 }.keys
       raise ConfigError, "llm.models has duplicates: #{duplicates.join(', ')}" unless duplicates.empty?
 

data/lib/aireview/prompts/jev_questions.yml

@@ -0,0 +1,79 @@
+# Jev questions about one candidate, the counterpart of critique.txt: the
+# rules are the same, only asked as separate yes/no and choice questions.
+# When critique.txt changes, change these too (spec/prompts_spec.rb checks
+# the key rules in both). %{id} is the candidate id; the state holds the
+# candidate at `candidates.<id>` and the diff at `diff`. Keys "true" and
+# "false" are quoted: YAML would read them as booleans.
+real_issue:
+  type: noul
+  instructions: >-
+    Is candidate `candidates.%{id}` a real, well-supported problem in the code
+    changed by this merge request?
+  criteria:
+    "true": >-
+      The problem is directly confirmed by the diff, the MR description, the
+      Jira task or the changed control/data flow, and it can lead to a real
+      defect, regression, security/performance issue, data loss or a mismatch
+      with the task. For category task_mismatch: the diff contains a concrete
+      artifact (debug code such as puts, p, binding.pry, byebug, console.log,
+      debugger; commented-out blocks; unused debug/test/helper methods;
+      temporary TODO/HACK/FIXME/DEBUG markers from this diff; disabled tests
+      such as skip, xit, pending without an explanation) or a change that
+      directly contradicts the MR or Jira.
+    "false": >-
+      The finding is not confirmed by the diff or Jira; it is based on an
+      assumption about code outside the diff; it contradicts the diff; it is
+      not actionable; it boils down to "may be redundant", "may conflict",
+      "may be unnecessary" or "worth checking" without a clear sign of
+      breakage, in any category. For category task_mismatch: implementation
+      details (config flags, deploy settings, new fields, helper methods),
+      accompanying refactoring and any change whose relation to the task is
+      plausible. A candidate with a `note` could not be anchored to the diff
+      mechanically and needs to be checked against the diff more carefully.
+      Missing text in a truncated part of the context does not mean a
+      missing requirement or missing code.
+enough_context:
+  type: noul
+  instructions: >-
+    Does the state contain enough to confirm or refute candidate
+    `candidates.%{id}`?
+  criteria:
+    "true": >-
+      The code the finding is about is present in `candidates.%{id}.evidence`
+      or in `diff`, and for a finding about the task the relevant MR or Jira
+      requirements are present and not cut off where they matter.
+    "false": >-
+      The decisive code or requirement is missing: the file is not shown, the
+      relevant part is truncated, or the finding depends on code or
+      requirements that are not in the state.
+version_claim:
+  type: noul
+  instructions: >-
+    Does candidate `candidates.%{id}` claim that a version of a package,
+    library, tool or image tag does not exist or has not been released yet?
+  criteria:
+    "true": >-
+      The finding says that a specified version does not exist, is not
+      released yet or is invalid because of its number.
+    "false": >-
+      The finding is about anything else, including syntax errors and explicit
+      contradictions with the MR or Jira requirements.
+# Only when the request holds more than one candidate; the options are the
+# other ids plus none.
+duplicate_of:
+  type: choice
+  instructions: >-
+    Does candidate `candidates.%{id}` describe the same problem as another
+    candidate?
+  other: The same problem as candidate `candidates.%{other}`.
+  none: A problem that no other candidate describes.
+# Goes to the log only; its answer does not decide anything yet.
+severity:
+  type: choice
+  instructions: >-
+    How severe is the problem described by candidate `candidates.%{id}`, if it
+    is real?
+  criteria:
+    critical: Breaks production behaviour, loses or corrupts data, or opens a security hole.
+    major: A real defect or regression on a common path, or a clear mismatch with the task.
+    minor: A limited edge case, a test gap or a maintainability issue.

data/lib/aireview/review_marker.rb

@@ -23,14 +23,19 @@ module Aireview
     # that way the diff, the MR description, the Jira context, the review
     # instructions and ignore_paths enter it by themselves. What else affects
     # the result — provider, model and temperature of the stages, the shared
-    # pool with its critique policy — is known by Config#result_signature.
-    # Without a pool the key is the same as before.
+    # pool with its critique policy, Jev as the critique engine — is known by
+    # Config#result_signature. Without a pool the key is the same as before.
+    # The LLM Critique counts only when it can run (its prompt is there),
+    # Jev only when it decides (its question templates are there): with the
+    # default engine the key is what it was before Jev.
     def key(prompts:, config:)
       signature = config.result_signature
       source = {
         'generate' => [*signature['generate'], prompts[:generate_prompt]],
         'critique' => prompts[:critique_prompt] ? [*signature['critique'], prompts[:critique_prompt]] : nil
       }
+      jev = prompts[:jev_questions]
+      source['critique_engine'] = [*signature['critique_engine'], jev] if jev
       source['pool'] = signature['pool'] if signature['pool']
 
       Digest::SHA256.hexdigest(JSON.generate(source))[0, 16]

data/lib/aireview/review_pipeline.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'json'
 require_relative 'errors'
+require_relative 'utils'
 require_relative 'stages'
 require_relative 'context_builder'
 require_relative 'candidate_checker'
@@ -8,12 +9,15 @@ require_relative 'result_parser'
 require_relative 'review_renderer'
 require_relative 'review_schemas'
 require_relative 'reviewer'
+require_relative 'jev_shadow'
+require_relative 'jev_stage'
+require_relative 'dry_run_prompts'
 
 module Aireview
   # A review run: context → Generate → anchoring check against the diff →
-  # Critique → report. Invalid JSON is repaired once by the same model; when
-  # the repair is invalid too, the stage restarts on another model with the
-  # original request.
+  # Critique (an LLM, or Jev with llm.critique.engine: jev) → report. Invalid
+  # JSON is repaired once by the same model; when the repair is invalid too,
+  # the stage restarts on another model with the original request.
   class ReviewPipeline
     SchemaError = ResultParser::SchemaError
 
@@ -23,20 +27,22 @@ module Aireview
       Do not use markdown, code fences, comments, or text outside JSON.
       Do not add new review findings.
     PROMPT
-    DRY_RUN_CANDIDATES_JSON = '[{"id":"C1","file":"path/from/diff.rb","line":1,' \
-                              '"quoted_code":"...","problem":"...","why":"...","suggestion":"...",' \
-                              '"category":"bug","severity":"major"}]'
     # Finish reasons after which an unparsable answer gets no repair.
     CUT_OFF_REASONS = {
       max_tokens: 'cut off at the output limit (max_tokens)',
       content_filter: 'blocked by the provider (content_filter)'
     }.freeze
 
-    def initialize(config:, reviewer: nil, context_builder: nil, logger: Logger.new($stderr))
+    # jev — jev_shadow: and jev_stage: for tests; by default they are built
+    # from the config, the stage only when Jev is the engine.
+    def initialize(config:, reviewer: nil, context_builder: nil, logger: Logger.new($stderr), **jev)
       @config = config
       @parser = ResultParser.new
       @reviewer = reviewer || Reviewer.new(config: config, logger: logger)
       @context_builder = context_builder || ContextBuilder.new(config: config, logger: logger)
+      @jev_shadow = jev[:jev_shadow] ||
+                    JevShadow.new(config: config, scrub: @context_builder.method(:scrub_text), logger: logger)
+      @jev_stage = jev[:jev_stage]
       @logger = logger
     end
 
@@ -63,7 +69,11 @@ module Aireview
                    "(model=#{@reviewer.answered_model('generate')})")
       candidates = check_candidates(context: context, changes: changes, candidates: candidates)
 
-      accepted = critique ? maybe_critique(context: context, candidates: candidates) : skip_critique(candidates)
+      accepted, jev_note = if critique
+                             maybe_critique(context: context, candidates: candidates)
+                           else
+                             skip_critique(candidates)
+                           end
 
       @logger.info("Pipeline finished with #{accepted.size} accepted finding(s)")
 
@@ -72,58 +82,19 @@ module Aireview
         summary: summary,
         coverage: context.coverage,
         fallback_models: @reviewer.fallback_models,
-        critique_weaker: critique && @reviewer.critique_weaker?
+        critique_weaker: critique && @reviewer.critique_weaker?,
+        jev_note: jev_note
       )
     end
 
+    # The prompts of the run and everything --dry-run shows; see DryRunPrompts.
     def dry_run_prompts(merge_request:, changes:, jira_issue: nil, critique: true)
-      @config.require_models!
-
-      context = @context_builder.prepare(
-        merge_request: merge_request,
-        changes: changes,
-        jira_issue: jira_issue,
-        critique: critique
-      )
-      generate_prompt = @context_builder.build_generate_prompt(context)
-      critique_prompt = if critique
-                          @context_builder.build_critique_prompt(context, candidates_json: DRY_RUN_CANDIDATES_JSON)
-                        end
-
-      {
-        generate_prompt: generate_prompt,
-        critique_prompt: critique_prompt,
-        generate_model: @config.generate_model,
-        generate_temperature: @config.generate_temperature,
-        critique_model: @config.critique_model,
-        critique_temperature: @config.critique_temperature,
-        generate_fallbacks: @config.fallback_names('generate'),
-        critique_fallbacks: critique ? @config.fallback_names('critique') : [],
-        sources: setting_sources(critique),
-        config_paths: @config.layer_paths,
-        warnings: @config.warnings,
-        critique_rule: critique ? @config.routing.rule : nil,
-        api_keys: @config.api_key_counts(critique ? STAGES : ['generate']),
-        time_budget: @config.llm_time_budget,
-        overloaded_quarantine: @config.overloaded_quarantine,
-        coverage: context.coverage,
-        sizes: context.sizes
-      }
+      DryRunPrompts.new(config: @config, context_builder: @context_builder, logger: @logger)
+        .build(merge_request: merge_request, changes: changes, jira_issue: jira_issue, critique: critique)
     end
 
     private
 
-    # Where the model, provider and reserves of a stage came from, for --dry-run.
-    def setting_sources(critique)
-      (critique ? %w[generate critique] : %w[generate]).to_h do |stage|
-        [stage.to_sym, {
-          model: @config.stage_model_source(stage),
-          provider: @config.stage_provider_source(stage),
-          fallbacks: @config.stage_fallbacks_source(stage)
-        }]
-      end
-    end
-
     # A stage is a request, parsing and one repair by the same model. An
     # invalid result after the repair, like a repair with no requests left,
     # excludes the model for the stage, and the stage starts over on the next
@@ -153,18 +124,32 @@ module Aireview
       ).check(candidates)
     end
 
+    # Returns the candidates and no report note, like every critique path.
     def skip_critique(candidates, reason = nil)
       @logger.info(['Pipeline critique pass skipped', reason].compact.join(': '))
-      candidates
+      [candidates, nil]
     end
 
     # Critique has nothing to filter without candidates: the LLM request
-    # would waste quota and time.
+    # would waste quota and time. Returns [accepted, note for the report].
     def maybe_critique(context:, candidates:)
       return skip_critique(candidates, 'no candidates') if candidates.empty?
+      return jev_critique(context: context, candidates: candidates) if @config.jev_critique?
 
       @logger.info("Pipeline critique pass started (model=#{@config.critique_model})")
-      critique_candidates(context: context, candidates: candidates)
+      accepted = critique_candidates(context: context, candidates: candidates)
+      @jev_shadow.run(context: context, candidates: candidates, accepted: accepted) if @config.jev_shadow?
+      [accepted, nil]
+    end
+
+    def jev_critique(context:, candidates:)
+      @jev_stage ||= JevStage.new(
+        config: @config, logger: @logger,
+        critic: JevCritic.build(config: @config, scrub: @context_builder.method(:scrub_text), logger: @logger)
+      )
+      llm_critique = ->(subset) { critique_candidates(context: context, candidates: subset) }
+      outcome = @jev_stage.run(context: context, candidates: candidates, llm_critique: llm_critique)
+      [outcome.accepted, outcome.note]
     end
 
     def critique_candidates(context:, candidates:)

data/lib/aireview/review_renderer.rb

@@ -47,6 +47,10 @@ module Aireview
         section_list: 'Truncated sections',
         fallback_used: 'Fallback model used',
         critique_weaker: 'Critique ran on a model weaker than Generate: the findings were checked less strictly.',
+        jev: 'The findings were checked by Jev, a fast classifier, without refining their wording.',
+        jev_partial: 'The findings were checked by Jev, a fast classifier, without refining their wording; ' \
+                     'those Jev could not judge were checked by the LLM critique.',
+        jev_failed: 'Jev was unavailable: the findings were checked by the LLM critique.',
         quote_missing: 'quote not found in the diff'
       },
       'ru' => {
@@ -74,6 +78,10 @@ module Aireview
         section_list: 'Усечённые секции',
         fallback_used: 'Использована резервная модель',
         critique_weaker: 'Критика выполнена моделью слабее generate: замечания проверены менее строго.',
+        jev: 'Замечания проверены быстрым классификатором Jev, без уточнения формулировок.',
+        jev_partial: 'Замечания проверены быстрым классификатором Jev, без уточнения формулировок; ' \
+                     'те, что Jev не смог оценить, проверила LLM-критика.',
+        jev_failed: 'Jev был недоступен: замечания проверила LLM-критика.',
         quote_missing: 'цитата не найдена в диффе'
       }
     }.freeze
@@ -86,7 +94,9 @@ module Aireview
     # result is still about the findings; incomplete coverage is written
     # next to it so that the result line does not read as "everything was
     # checked".
-    def render(accepted, summary:, coverage: nil, fallback_models: {}, critique_weaker: false)
+    # jev_note — how Jev took part in the critique (see JevStage::Outcome).
+    # The facts about the run are named one by one on purpose.
+    def render(accepted, summary:, coverage: nil, fallback_models: {}, critique_weaker: false, jev_note: nil) # rubocop:disable Metrics/ParameterLists
       mismatches, important = select_findings(Array(accepted))
       result = mismatches.empty? && important.empty? ? 'ok' : 'needs attention'
 
@@ -106,7 +116,7 @@ module Aireview
         ## #{label(:result)}
 
         #{result}#{partial_note(coverage)}
-        #{coverage_block(coverage)}#{fallback_note(fallback_models)}#{weaker_note(critique_weaker)}
+        #{coverage_block(coverage)}#{fallback_note(fallback_models)}#{weaker_note(critique_weaker)}#{jev_note(jev_note)}
         #{label(:disclaimer)}
       MARKDOWN
     end
@@ -191,6 +201,12 @@ module Aireview
       "\n#{label(:critique_weaker)}\n"
     end
 
+    # Jev decides keep/reject but cannot refine: the reader should know the
+    # wording is the first pass's own.
+    def jev_note(note)
+      note ? "\n#{label(note)}\n" : ''
+    end
+
     def fallback_note(fallback_models)
       return '' if fallback_models.nil? || fallback_models.empty?