aireview 2.0.0 → 2.2.0

data/lib/aireview/llm_client.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'json'
 require 'timeout'
 require_relative 'errors'
 require_relative 'utils'
@@ -22,29 +23,58 @@ module Aireview
       @contexts = {}
     end
 
-    # Returns the RubyLLM answer (content is text or a structure by the
-    # schema). A request error is re-raised as is — LlmFailure classifies it.
+    # Returns the RubyLLM answer; read it with LlmClient.content. A request
+    # error is re-raised as is — LlmFailure classifies it.
     def request(prompt, candidate:, key:, timeout:, key_index: 0)
       load_ruby_llm
       stage = prompt.stage.to_s
       model = candidate.model
       @logger.info("LLM #{stage} request started (model=#{model}, temperature=#{prompt.temperature})")
-      chat = build_chat(context: context(stage, candidate.provider, key, key_index), stage: stage,
+      chat = build_chat(context: context(stage, candidate, key, key_index), stage: stage,
                         model: model, provider: candidate.provider)
       chat = configure_reasoning(chat: chat, model: model, provider: candidate.provider)
         .with_temperature(prompt.temperature.to_f)
         .with_schema(prompt.schema)
       chat.with_instructions(prompt.system)
       response = Timeout.timeout(timeout) { chat.ask(prompt.user) }
-      @logger.info("LLM #{stage} request completed (model=#{model})")
+      @logger.info("LLM #{stage} request completed (model=#{model}#{token_counts(response)})")
       response
     rescue Timeout::Error
       @logger.warn("LLM #{stage} request timed out after #{timeout.round} seconds (model=#{model})")
       raise
     end
 
+    # The answer as RubyLLM 1.x gave it under a schema: the parsed JSON when
+    # the text is JSON, the text itself otherwise (the pipeline repairs it).
+    # RubyLLM 2 always returns the text, and a Hash that breaks the schema
+    # would go to a repair request instead of the next model. An empty
+    # answer stays an empty String (Message#parsed would turn it into nil);
+    # JSON null becomes nil, as in 1.x.
+    def self.content(response)
+      content = response.content
+      return content unless content.is_a?(String) && !content.empty?
+
+      response.parsed
+    rescue JSON::ParserError
+      content
+    end
+
     private
 
+    # Token counts as the provider reported them, one line per attempt. They
+    # are not summed: Gemini already counts thinking into output. Input is
+    # what was not read from or written to a cache; the prompt size is
+    # input + cache_read + cache_write, and a retry of the same prompt on
+    # Gemini is often served from its implicit cache.
+    def token_counts(response)
+      tokens = response.tokens
+      cached = {cache_read: tokens.cache_read, cache_write: tokens.cache_write}.reject { |_, count| count.to_i.zero? }
+      counts = {input: tokens.input, output: tokens.output, thinking: tokens.thinking}.compact.merge(cached)
+      return '' if counts.empty?
+
+      ", tokens: #{counts.map { |name, count| "#{name}=#{count}" }.join(' ')}"
+    end
+
     def load_ruby_llm
       require 'ruby_llm'
     rescue LoadError => e
@@ -69,18 +99,19 @@ module Aireview
       context.chat(model: model, provider: provider.to_sym, assume_model_exists: true)
     end
 
-    # A RubyLLM context per stage, provider and key index: switching the key
-    # is another context, not an edit of the global config.
-    def context(stage, provider, key, key_index)
-      @contexts[[stage, provider, key_index]] ||= build_context(provider.to_s, key)
+    # A RubyLLM context per stage, key source (a provider's API or a server
+    # of your own) and key index: switching the key is another context, not
+    # an edit of the global config.
+    def context(stage, candidate, key, key_index)
+      @contexts[[stage, candidate.key_source, key_index]] ||= build_context(candidate, key)
     end
 
-    def build_context(provider, api_key)
+    def build_context(candidate, api_key)
       RubyLLM.context do |ruby_config|
         configure_http_proxy(ruby_config)
         ruby_config.request_timeout = @config.llm_timeout.to_f
         ruby_config.max_retries = 0
-        configure_provider(ruby_config, provider, api_key)
+        configure_provider(ruby_config, candidate.provider.to_s, api_key, candidate.api_base)
       end
     end
 
@@ -90,24 +121,30 @@ module Aireview
       ruby_config.http_proxy = @config.llm_http_proxy
     end
 
-    def configure_provider(ruby_config, provider, api_key)
+    # api_base — the model's own server; without it the provider's API,
+    # or LLM_API_BASE for the providers that always took it.
+    def configure_provider(ruby_config, provider, api_key, api_base)
       case provider
       when 'gemini', 'openai', 'openrouter'
-        configure_remote_provider(ruby_config, provider, api_key)
+        configure_remote_provider(ruby_config, provider, api_key, api_base || @config.llm_api_base)
       when 'anthropic'
         ruby_config.anthropic_api_key = api_key
+        ruby_config.anthropic_api_base = api_base if api_base
       when 'ollama'
-        ruby_config.ollama_api_base = @config.ollama_api_base
+        ruby_config.ollama_api_base = api_base || @config.ollama_api_base
       else
         raise ConfigError, "Unsupported LLM provider: #{provider.inspect}"
       end
     end
 
-    def configure_remote_provider(ruby_config, provider, api_key)
+    # RubyLLM 2 sends OpenAI requests to the Responses API; a compatible
+    # server usually has Chat Completions only.
+    def configure_remote_provider(ruby_config, provider, api_key, api_base)
       ruby_config.public_send("#{provider}_api_key=", api_key)
-      return unless Aireview::Utils.present?(@config.llm_api_base)
+      ruby_config.openai_protocol = :chat_completions if provider == 'openai'
+      return unless Aireview::Utils.present?(api_base)
 
-      ruby_config.public_send("#{provider}_api_base=", @config.llm_api_base)
+      ruby_config.public_send("#{provider}_api_base=", api_base)
     end
   end
 end

data/lib/aireview/llm_router.rb

@@ -34,7 +34,7 @@ module Aireview
 
     Slot = Struct.new(:candidate, :index)
     # The key the next model of the same provider continues from.
-    Carry = Struct.new(:provider, :key_index)
+    Carry = Struct.new(:key_source, :key_index)
     Delay = Struct.new(:seconds, :source)
 
     SWITCH_HINT = 'Try again later or switch model via --generate-model/--critique-model.'
@@ -213,7 +213,7 @@ module Aireview
         log_switch(stage, route, visits)
         status, response = try_route(stage, route, visits, &request)
         return [:ok, remember(stage, route, response)] if status == :ok
-        return [:next_model, Carry.new(route.candidate.provider, route.key_index)] if status == :next_model
+        return [:next_model, Carry.new(route.candidate.key_source, route.key_index)] if status == :next_model
       end
       state(slot.candidate).exclude('daily quota exhausted on every key') unless tried
       [:next_model, carry]
@@ -224,7 +224,7 @@ module Aireview
     # is bound to "key + model", a failure on one model does not write the
     # key off for another.
     def candidate_routes(stage, slot, carry)
-      keys = @config.provider_api_keys(slot.candidate.provider)
+      keys = @config.candidate_api_keys(slot.candidate)
       routes = keys.each_with_index.map do |key, key_index|
         Route.new(candidate: slot.candidate, candidate_index: slot.index, key: key,
                   key_index: key_index, key_count: keys.size)
@@ -233,7 +233,7 @@ module Aireview
     end
 
     def start_key(stage, slot, carry)
-      return carry.key_index if carry && carry.provider == slot.candidate.provider
+      return carry.key_index if carry && carry.key_source == slot.candidate.key_source
 
       cursor_candidate, cursor_key = @cursor.fetch(stage, [0, 0])
       cursor_candidate == slot.index ? cursor_key : 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,8 +121,38 @@ 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
-      @client.request(request, candidate: candidate, key: key, timeout: @config.llm_timeout.to_f).content
+      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

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/output_schemas.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'ruby_llm/schema'
+require 'schematist'
 
 module Aireview
   module OutputSchemaValues
@@ -18,7 +18,7 @@ module Aireview
     DECISIONS = %w[keep reject].freeze
   end
 
-  class GenerateOutputSchema < RubyLLM::Schema
+  class GenerateOutputSchema < Schematist::Schema
     string :summary
     array :candidates, max_items: 3 do
       object do
@@ -38,7 +38,7 @@ module Aireview
     end
   end
 
-  class CritiqueOutputSchema < RubyLLM::Schema
+  class CritiqueOutputSchema < Schematist::Schema
     array :verdicts do
       object do
         string :id

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]