ace-review 0.58.0 → 0.58.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fda3bb688af1e2d4c71e6f37dc20d25c4f756703c3a2910827629975fd0965e1
-  data.tar.gz: a479d205b501a785063680654466e0eda84e5d00397cc74831dbffc24d106552
+  metadata.gz: b74a181828465000d62fedc0062c118681144724a8beec940af5a335dade03b7
+  data.tar.gz: 700918d82fb6f27833a1b0f054301912d1a99dd5609b6140d93ff155a272f0b5
 SHA512:
-  metadata.gz: b5d61e56ef9b7c8cd02a8c44130e4c0d43266d3327290e963136f36b442a596d6070b9736d94f46427265be4696bc43c4d0e8c69142eaa4fd5019a0e6db31b9c
-  data.tar.gz: 0dde4d996c5f713b5f5babfe57f03814cfe658d217207071da16f8248e387e14bad4916184e8175c0f603842efac319636a73d5e1394b6b92a7c29dea072b208
+  metadata.gz: 3747d044dc834fe44d7977dfa120052709e5db45885a0c4fa39f7bbb60d4b819e6ea4c0f1f70c7189229b580f565b8936e6d5c1821ca04d4eb787a4cc84add61
+  data.tar.gz: 8ac3e30edd97356132095db4deca911ec62db8ba4c8ab0b92f7de8a11a8b6464cf5a9404180d8420d6eb18badb398ec158ee9e6f1b60a37f117d0dfbd4f6d6b6

data/.ace-defaults/review/presets/code-fit.yml

@@ -60,6 +60,7 @@ instructions:
 bundle: "project"
 
 models:
-  - role:review-claude
-  - role:review-codex
-  - role:review-gemini
+  # One reviewer position with fallback chain (roles in ace-llm config):
+  # pi glm 5.3 -> codex sol -> agy flash 3.8; the round is good if even
+  # one returns. astra runs once per PR via role:review-astra.
+  - role:review-default

data/.ace-defaults/review/presets/code-shine.yml

@@ -40,5 +40,4 @@ instructions:
 bundle: "project"
 
 models:
-  - role:review-claude
-  - role:review-codex
+  - role:review-default

data/.ace-defaults/review/presets/code-valid.yml

@@ -35,6 +35,7 @@ instructions:
 bundle: "project"
 
 models:
-  - role:review-claude
-  - role:review-codex
-  - role:review-gemini
+  # One reviewer position with fallback chain (roles in ace-llm config):
+  # pi glm 5.3 -> codex sol -> agy flash 3.8; the round is good if even
+  # one returns. astra runs once per PR via role:review-astra.
+  - role:review-default

data/CHANGELOG.md

@@ -7,15 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.58.1] - 2026-10-02
+
+### Fixed
+- Campaign finish scopes availability re-hashing to the newest round's evidence and the content-addressed finding snapshots; earlier rounds validate through journal-backed historical authority reads, so resolving findings no longer permanently blocks finish.
+
+
 ## [0.58.0] - 2026-10-02
 
 ### Added
 - Provider-neutral PR reviews and comment handling for GitHub, default Forgejo, and named Forgejo servers with exact-head evidence.
 
 ### Changed
+- Review model queries honor the configured ace-llm fallback (role candidate
+  chains + `llm.fallback`) instead of forcing single-leg execution, so a
+  reviewer position survives a dead provider leg.
 - Replaced `--gh-timeout` with `--provider-timeout`; removed the GitHub-only review fetcher, poster, and resolver paths.
 - Preserve provider and repository identity across review sessions and comments; fail closed on moved heads and collection errors.
 
+## [0.57.1] - 2026-10-02
+
+### Fixed
+
+- A failed or incomplete provider entry no longer invalidates a campaign session's completed reviewer executions; one completed reviewer per needed scope still completes the round.
+
 
 ## [0.57.0] - 2026-10-01
 

data/lib/ace/review/atoms/pr_comment_formatter.rb

@@ -42,18 +42,19 @@ module Ace
           end
           review_threads = comments_data[:review_threads] || []
 
-          # Build report sections
-          frontmatter = build_frontmatter(comments_data)
-          summary = build_summary(comments, reviews, review_threads, pr_number, pr_title)
           # Apply the same bot filter to thread comments; threads left
-          # without human comments are omitted from feedback.
+          # without human comments are omitted from feedback (filtered
+          # before the summary so bot-only threads never inflate counts).
           review_threads = review_threads.map do |thread|
             filtered = thread.merge(comments: Array(thread[:comments]).reject { |c| c[:author].to_s.match?(/\b(bot|github-actions|ace-review)\b/i) })
             filtered.merge(comments: filtered[:comments])
           end.reject { |thread| Array(thread[:comments]).empty? }
+          # Build report sections
+          frontmatter = build_frontmatter(comments_data)
+          summary = build_summary(comments, reviews, review_threads, pr_number, pr_title)
           inline_section = build_inline_comments_section(review_threads)
           unresolved_section = build_unresolved_section(comments, reviews)
-          resolved_section = build_resolved_section(reviews)
+          resolved_section = build_resolved_section(reviews, current_head: comments_data[:head_sha].to_s)
           comments_table = build_comments_table(comments, reviews)
 
           # Combine sections
@@ -190,13 +191,26 @@ module Ace
         # Build resolved feedback section
         #
         # @param reviews [Array<Hash>] Code reviews
+        # @param current_head [String] Reviewed PR head (empty when unknown)
         # @return [String, nil] Resolved section or nil if empty
-        def self.build_resolved_section(reviews)
+        def self.build_resolved_section(reviews, current_head: nil)
           resolved = []
+          current = current_head.to_s
 
-          # Add approvals
+          # Add approvals. Approvals attach to a reviewed commit; only those
+          # matching the current head are current approvals, earlier-head
+          # approvals are labeled, and unknown-head approvals are called out
+          # as unknown instead of presenting as current.
           reviews.select { |r| r[:state] == "APPROVED" }.each do |review|
-            resolved << "@#{review[:author]} approved changes"
+            review_head = review[:head_sha].to_s
+            label = if review_head.empty?
+                      " (head unknown)"
+                    elsif review_head == current
+                      ""
+                    else
+                      " (for earlier head #{review_head[0, 12]})"
+                    end
+            resolved << "@#{review[:author]} approved changes#{label}"
           end
 
           return nil if resolved.empty?

data/lib/ace/review/molecules/campaign_evidence.rb

@@ -18,6 +18,16 @@ module Ace
       class CampaignEvidence
         Contract = Atoms::CampaignContract
 
+        # One completion predicate for provider executions, shared with the
+        # extraction-inventory writer so session metadata and campaign
+        # evidence can never disagree about which reports were reviewed.
+        def self.completed_entry?(entry)
+          execution = entry["execution"] || {}
+          entry["status"] == "success" && execution["status"].to_s == "succeeded" &&
+            !execution["provider"].to_s.empty? && !execution["model"].to_s.empty? &&
+            !entry["completed_at"].to_s.empty?
+        end
+
         def initialize(repo_root:, check_evidence: nil, review_evidence: nil, approval_evidence: nil)
           @repo_root = File.realpath(repo_root)
           authority = CampaignExecutionEvidence.new(repo_root: @repo_root)
@@ -57,9 +67,9 @@ module Ace
           metadata = json_keys(YAML.safe_load_file(metadata_path, permitted_classes: [Time, Date, Symbol]))
           Contract.object!(metadata, "session metadata")
           expected = {"campaign_id" => record["id"], "contract_identity" => record["contract_identity"],
-            "subject" => record["subject"], "round_id" => binding["round_id"], "scope" => scope,
-            "head" => binding["head"], "base" => binding["base"],
-            "scope_identity" => binding["scope_identity"][scope]}
+                      "subject" => record["subject"], "round_id" => binding["round_id"], "scope" => scope,
+                      "head" => binding["head"], "base" => binding["base"],
+                      "scope_identity" => binding["scope_identity"][scope]}
           unless metadata["campaign_binding"] == expected && metadata["preset"] == expected["scope_identity"]["preset"]
             raise Contract::Invalid, "session campaign/contract/scope/head/base identity mismatch"
           end
@@ -83,12 +93,7 @@ module Ace
           reports = []
           entries.each do |entry|
             Contract.object!(entry, "model execution")
-            execution = entry["execution"] || {}
-            complete = entry["status"] == "success" && execution["status"] == "succeeded" &&
-              !execution["provider"].to_s.empty? && !execution["model"].to_s.empty? &&
-              !entry["completed_at"].to_s.empty?
-            completed &&= complete
-            next unless complete
+            next unless self.class.completed_entry?(entry)
             path = entry["output_file"].to_s
             raise Contract::Invalid, "completed execution has no report" if path.empty?
             path = File.expand_path(path, dir)
@@ -99,7 +104,7 @@ module Ace
             resolved, report_ref = artifact("path" => path, "sha256" => entry["report_sha256"])
             raise Contract::Invalid, "empty reviewer report" if File.read(resolved).strip.empty?
             refs << report_ref
-            reports << {"artifact" => report_ref, "execution" => execution}
+            reports << {"artifact" => report_ref, "execution" => entry["execution"] || {}}
             prompts = entry["prompt_sha256"]
             Contract.object!(prompts, "execution prompt checksums")
             %w[system user].each do |name|
@@ -117,6 +122,10 @@ module Ace
               raise Contract::Invalid, "feedback extraction inventory or reviewed reports changed"
             end
           end
+          # One completed reviewer per needed scope suffices: a failed or
+          # incomplete provider entry does not count as a reviewer, but it
+          # does not invalidate the model executions that did complete.
+          completed &&= reports.any?
           completed &&= extracted
           proof = completed ? @review_evidence.call(input.fetch("receipt"), head: binding["head"], artifacts: refs) : nil
           {"receipt" => input["receipt"], "execution_proof" => proof, "path" => dir.delete_prefix(@repo_root + File::SEPARATOR), "scope" => scope,

data/lib/ace/review/molecules/llm_executor.rb

@@ -113,8 +113,11 @@ module Ace
             output: output_file,
             format: "text",
             timeout: timeout || Ace::Review.get("defaults", "llm_timeout") || 300,
-            force: true,
-            fallback: false  # Disable ace-llm fallback - ace-review handles retries
+            force: true
+            # Fallback is config-driven (llm.fallback + role candidate
+            # chains): the reviewer position tries pi glm 5.3, then codex
+            # sol, then agy flash 3.8 — the round is good if even one
+            # returns, and the session records the winner only.
           )
 
           unless result[:text].is_a?(String) && !result[:text].strip.empty?

data/lib/ace/review/molecules/pr_provider.rb

@@ -141,8 +141,11 @@ module Ace
              comments: [{id: comment.id, author: comment.author, body: comment.body, url: comment.url}]}
           end
           reviews = snapshot.review_evidence.reviews.map do |review|
+            # Carry the reviewed commit so the formatter can tell
+            # current-head approvals from approvals of earlier heads.
             {id: review.id, author: review.author, body: review.body,
-             state: review.state.to_s.upcase, url: review.url}
+             state: review.state.to_s.upcase, url: review.url,
+             head_sha: review.head_sha}
           end
           {
             success: true, comments: issue_comments, review_threads: threads,

data/lib/ace/review/organisms/campaign_manager.rb

@@ -310,7 +310,16 @@ module Ace
             revision_error = e.message
           end
           round = record["rounds"].last
-          refs = record["attempts"].flat_map do |attempt|
+          # Availability re-hashing covers the current round's evidence plus
+          # every finding snapshot. Earlier rounds' sessions and approvals are
+          # validated by journal-backed historical authority reads instead:
+          # their working files legitimately age (feedback resolve archives
+          # and annotates finding files; test report `latest` paths move on),
+          # so hashing them here would permanently block finish for any
+          # campaign that resolved findings. Finding snapshots are
+          # content-addressed and must remain available.
+          current_attempt_ids = round ? [round["attempt_id"]] : []
+          refs = record["attempts"].select { |attempt| current_attempt_ids.include?(attempt["attempt_id"]) }.flat_map do |attempt|
             attempt["sessions"].flat_map { |session| session["artifacts"] } +
               (attempt["approval"] ? [attempt["approval"]["artifact"]] + attempt["approval"]["artifacts"] : [])
           end + (record["assessments"] + record["inherited_findings"]).map { |finding| finding["artifact"] }

data/lib/ace/review/organisms/review_manager.rb

@@ -376,6 +376,18 @@ module Ace
           delta = Molecules::DeltaResolver.resolve(options.delta, metadata, project_root: @project_root || Dir.pwd)
           return {success: false, error: delta[:error]} unless delta[:success]
 
+          # The snapshot above was read before resolution ran; re-read the
+          # provider metadata and compare identity so a head, base, or
+          # repository move during delta computation fails the round instead
+          # of certifying a delta against stale identity.
+          recheck_result = pr_provider(options).fetch_metadata(pr_identifier)
+          return {success: false, error: recheck_result[:error]} unless recheck_result[:success]
+          rechecked = recheck_result[:metadata]
+          identity_keys = %w[server_name provider repository_url number headRefOid baseRefOid]
+          if identity_keys.any? { |key| rechecked[key] != metadata[key] }
+            return {success: false, error: "PR identity changed during delta resolution; delta round rejected"}
+          end
+
           options.pr_metadata = metadata
           # Carry the reference session's findings forward as evidence; an explicit
           # --evidence-session still merges on top.
@@ -413,7 +425,8 @@ module Ace
                       pr_metadata: metadata, delta: delta,
                       diff_manifest: manifest.merge(scoped[:manifest]).merge(
                         exempt_files: classification[:exempt],
-                        exempt_patterns: Array(config[:exempt_paths]))}
+                        exempt_patterns: Array(config[:exempt_paths])
+                      )}
             end
 
             scoped = apply_exempt_paths(scoped, config)
@@ -494,10 +507,10 @@ module Ace
           lines << ""
           lines << "# No-op review round"
           lines << ""
-          if content[:noop_reason] == :empty_delta && delta
-            lines << "Scope: delta since `#{delta[:reference_head]}` — the delta is empty; there is no change to review."
+          lines << if content[:noop_reason] == :empty_delta && delta
+            "Scope: delta since `#{delta[:reference_head]}` — the delta is empty; there is no change to review."
           else
-            lines << "Scope: #{content[:noop_scope] || "no-op"}."
+            "Scope: #{content[:noop_scope] || "no-op"}."
           end
           lines << ""
           lines << "Verdict: no new findings. This round is clean only if no carried-forward Critical/High finding remains unresolved."
@@ -1395,13 +1408,21 @@ module Ace
           # Read review content
           review_content = File.read(review_file)
 
+          # The identity digest covers only stable review content: the
+          # metadata header carries a fresh timestamp on every run, so hashing
+          # the whole file would mint a new identity for identical review
+          # text and let an uncertain-post retry post a duplicate. The
+          # dry-run preview uses the same digest so preview and post agree.
+          stable_content = review_content.sub(/\A---\n.*?\n---\n\n/m, "")
+          review_digest = Digest::SHA256.hexdigest(stable_content)
+
           # Dry-run prepares the exact comment body without posting; the
           # response builder reads :preview. The timestamp derives from the
           # review digest — identical to what a real post would send.
           if options.dry_run
             preview = Molecules::PrProvider.format_comment(
               review_content, preset: review_data[:preset], model: review_data[:model],
-              timestamp: "review-#{Digest::SHA256.file(review_file).hexdigest[0, 12]}"
+              timestamp: "review-#{review_digest[0, 12]}"
             )
             return {success: true, dry_run: true, preview: preview}
           end
@@ -1416,7 +1437,6 @@ module Ace
           # keyed by everything reuse depends on: PR identity, head, and
           # the review artifact digest. Identical review text for another
           # PR therefore never collides.
-          review_digest = Digest::SHA256.file(review_file).hexdigest
           # The numeric PR (not the raw reference spelling) keys the
           # persisted identity, matching the provider-side marker basis.
           identity_pr = (options.pr_metadata&.fetch("number", nil) || options.pr).to_s
@@ -1429,6 +1449,10 @@ module Ace
           # any new timestamp is generated.
           identity_preset = review_data[:preset].to_s
           identity_model = review_data[:model].to_s
+          # The identity includes the review artifact digest: a retry of
+          # the same artifact reuses the persisted marker (no duplicate),
+          # while a regenerated review for a later round is a new artifact
+          # and gets its own comment.
           identity_key = Digest::SHA256.hexdigest(
             [identity_server, identity_repo, identity_pr, identity_head, review_digest,
              identity_preset, identity_model].join("\0")
@@ -1454,10 +1478,13 @@ module Ace
           else
             # The marker IS the identity key: deterministic for the same
             # identity even when the local record was lost, so the posted
-            # body and correlation always reconcile.
+            # body and correlation always reconcile. The body is formatted
+            # from the same stable content the digest hashes: embedding the
+            # timestamped frontmatter would make a rerun with identical
+            # review text report a content conflict after a lost record.
             session_key = identity_key
             content = Molecules::PrProvider.format_comment(
-              review_content, preset: review_data[:preset], model: review_data[:model],
+              stable_content, preset: review_data[:preset], model: review_data[:model],
               # Deterministic per identity: the review digest stands in
               # for the mtime so re-formatting after a lost record still
               # reconciles.
@@ -1496,8 +1523,12 @@ module Ace
           reviewed_server = options.pr_metadata&.fetch("server_name", nil)
           reviewed_repo = options.pr_metadata&.fetch("repository_url", nil)
           reviewed_number = options.pr_metadata&.fetch("number", nil)
+          # Normalize both sides: forgejo strips .git from its PR URL while
+          # comment evidence retains the configured URL, so exact comparison
+          # would fail a successful post.
+          normalize = ->(url) { url.to_s.chomp("/").sub(/\.git\z/i, "") }
           if (reviewed_server && receipt.comment.server_name != reviewed_server) ||
-             (reviewed_repo && receipt.comment.repository_url != reviewed_repo) ||
+             (reviewed_repo && normalize.call(receipt.comment.repository_url) != normalize.call(reviewed_repo)) ||
              (reviewed_number && receipt.comment.pr_number != reviewed_number)
             raise Ace::Git::ProviderIdentityMismatchError,
               "Posted comment identity (#{receipt.comment.server_name}/#{receipt.comment.repository_url}##{receipt.comment.pr_number}) does not match the reviewed PR"
@@ -1757,7 +1788,17 @@ module Ace
         # completes; an absent directory cannot attest a zero-findings review.
         def save_campaign_feedback_metadata(session_dir, result)
           path = File.join(session_dir, "metadata.yml")
-          metadata = YAML.safe_load_file(path, permitted_classes: [Time, Date, Symbol])
+          # Session metadata is symbol-keyed YAML; normalize before any key
+          # reads so the completed-execution rule and the binding check see
+          # string keys, matching the campaign evidence reader.
+          normalize = lambda do |value|
+            case value
+            when Hash then value.to_h { |k, v| [k.to_s, normalize.call(v)] }
+            when Array then value.map { |v| normalize.call(v) }
+            else value
+            end
+          end
+          metadata = normalize.call(YAML.safe_load_file(path, permitted_classes: [Time, Date, Symbol]))
           return unless metadata["campaign_binding"]
           extraction = {"status" => result ? "failed" : "skipped"}
           if result && result[:success]
@@ -1770,9 +1811,13 @@ module Ace
             unless result[:items_count] == ids.size && ids.uniq.size == ids.size
               raise Errors::BundleProcessingError, "feedback extraction inventory is incomplete"
             end
-            entries = metadata["models"] || [YAML.safe_load_file(File.join(session_dir, "llm_metadata.yml"),
-              permitted_classes: [Time, Date, Symbol])]
-            digests = entries.map { |entry| entry["report_sha256"] }.compact
+            entries = metadata["models"] || [normalize.call(YAML.safe_load_file(
+              File.join(session_dir, "llm_metadata.yml"), permitted_classes: [Time, Date, Symbol]
+            ))]
+            # Same completed rule as the campaign evidence reader: a failed
+            # provider that left partial output is not a reviewed report.
+            digests = entries.select { |entry| Molecules::CampaignEvidence.completed_entry?(entry) }
+              .map { |entry| entry["report_sha256"] }.compact
             extraction = {"status" => "succeeded", "finding_ids" => ids, "report_sha256" => digests}
           end
           metadata["feedback_extraction"] = extraction

data/lib/ace/review/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Review
-    VERSION = "0.58.0"
+    VERSION = "0.58.1"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-review
 version: !ruby/object:Gem::Version
-  version: 0.58.0
+  version: 0.58.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli