ace-review 0.51.7 → 0.53.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6e9694e9a121f9b6b18479d7be2be32511483940cd667f842493b35b8c9d359
-  data.tar.gz: e973c776a7b792365c3974fca973c31337529734f5eb0eda424da53c796e9cd6
+  metadata.gz: 647741c9f1b7814b5471a9a07c4f1693ac649f953d3f530bae67516a81cd7f0d
+  data.tar.gz: 520c59a0dda292b28d383215606fb7463d64d35f3b3ef0c024428243f2dc0870
 SHA512:
-  metadata.gz: 9cb47a01bb00b68312c42c57b8fe694434818bcb813e1630711b5302fbf8b8caf0181239ce9b1932fdc9ade415de055fbee71f3a94b8ad01f61d9366d605de70
-  data.tar.gz: f399541bbdd6d3ff98fddcb8d9c1305fb9ac73aff6a6f87058cbbeb0766a32ffc6498808a743e8052860e55724400fcf268ffaae6a4740baa44a0b3632f73190
+  metadata.gz: cb3239ee728103949252327de0a7b97de54ea1747ca3a8c2c2fd1e930281091bcb57ce14de3ca44041bf2d95d14608883b753f4af2b85f2d4d019fd4829bfb32
+  data.tar.gz: 892722919f96459f188ddd278f8d42f0538f81297fd9c87729302ca2072f9c62901f58396a7a17a72bb6c677394eb1f341927c2b3a0d53b199450a8dd845d0a1

data/CHANGELOG.md

@@ -7,8 +7,79 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.53.6] - 2026-04-24
+
+### Fixed
+- Sized review prompts and adaptive review execution against the resolved concrete model target so role and alias-based reviews no longer rely on provider-wide context assumptions.
+
+## [0.53.5] - 2026-04-19
+
+### Technical
+- Stabilized retained multi-model and reviewers-format E2E fixtures by pinning them to installed direct review models instead of ambient mixed-provider availability.
+
+## [0.53.4] - 2026-04-16
+
+### Technical
+- Hardened retained multi-model and docs-path review E2E runners to persist `.stdout`, `.stderr`, and `.exit` artifacts consistently across success, timeout, and provider-constrained paths.
+
+## [0.53.3] - 2026-04-16
+
+### Fixed
+- Updated retained `TS-REVIEW-001` execution fixtures to use installed direct review models, require explicit diff subjects, and drive the single/multi-model flows through the public executable review path instead of stopping at session preparation.
+
+## [0.53.2] - 2026-04-16
+
+### Fixed
+- Switched retained `TS-REVIEW-001` multi-model fixtures from the missing `review-claude` role to installed review roles so the scenario validates real multi-provider review execution instead of local CLI availability drift.
+
+## [0.53.1] - 2026-04-16
+
+### Fixed
+- Updated docs-path onboarding E2E verification to accept bounded timeout evidence when help discovery and review session artifacts prove the documented path is discoverable.
+
+## [0.53.0] - 2026-04-15
+
+### Changed
+- Rewrote retained `TS-REVIEW-001` E2E goals to enforce public docs/help command-path guidance and added
+  `TC-003-docs-path-onboarding` coverage.
+- Tightened E2E verifier contracts so provider/model unavailability is treated as a failure path instead of a
+  PASS-equivalent outcome.
+
+### Technical
+- Updated scenario manifests and decision records to reflect three-goal execution (`X/3`) and the strict outcome
+  policy for onboarding-facing review workflows.
+
+## [0.52.1] - 2026-04-13
+
+### Changed
+- Completed the batch i05 migration follow-through for this package and aligned it with the restarted `fast` / `feat` / `e2e` verification model.
+
+### Technical
+- Included in the coordinated assignment-driven patch release for batch i05 package updates.
+
+
+## [0.52.0] - 2026-04-12
+
+### Changed
+- Migrated package tests to the restarted `fast` / `feat` / `e2e` contract:
+  - moved deterministic package tests from legacy top-level folders into `test/fast/`
+  - moved former `test/integration/` deterministic coverage into `test/feat/`
+  - rewrote `TS-REVIEW-001` to retain only high-value execution workflows and added an E2E decision record
+- Updated package docs to teach `ace-test ace-review`, `ace-test ace-review feat`, `ace-test ace-review all`, and `ace-test-e2e ace-review`.
+- Expanded `as-review-pr` canonical skill metadata so public `review-pr` assign-step discovery is skill-owned rather than catalog-owned.
+- Switched review GitHub CLI operations to use `Ace::Git::Molecules::GhCliExecutor` and removed the package-local `GhCliExecutor` implementation.
+
 ### Fixed
 - Added `diff:RANGE -- path` subject parsing so reviews can scope git diffs to specific files or directories with git-style path filters.
+- Updated review GitHub workflows to correctly re-raise `Ace::Git` authentication/install errors after migrating to shared `GhCliExecutor`.
+
+## [0.51.10] - 2026-04-07
+
+### Changed
+- Switched review GitHub CLI integrations to shared `Ace::Git::Molecules::GhCliExecutor` to remove duplicate implementations and align error handling with other packages.
+
+### Fixed
+- Preserved review-path authentication and install error behavior after the executor migration.
 
 ## [0.51.6] - 2026-03-31
 

data/README.md

@@ -38,5 +38,21 @@
 
 **Audit review history through session artifacts** - keep saved review sessions under `.ace-local/` for traceability, comparison, and handoff across contributors.
 
+## Testing
+
+Run package deterministic checks with:
+
+```bash
+ace-test ace-review
+ace-test ace-review feat
+ace-test ace-review all
+```
+
+Run retained workflow scenarios with:
+
+```bash
+ace-test-e2e ace-review
+```
+
 ---
 [Getting Started](docs/getting-started.md) | [Usage Guide](docs/usage.md) | [Handbook - Skills, Agents, Templates](docs/handbook.md) | Part of [ACE](https://github.com/cs3b/ace)

data/handbook/skills/as-review-pr/SKILL.md

@@ -22,10 +22,19 @@ integration:
     - pi
   providers: {}
 assign:
-  source: wfi://review/pr
   steps:
     - name: review-pr
       description: Review code changes for correctness, style, and best practices
+      prerequisites:
+        - name: create-pr
+          strength: required
+          reason: "Must have a PR to review"
+      produces: [review-feedback]
+      consumes: [pull-request]
+      when_to_skip:
+        - "No code changes since last review"
+        - "Changes are trivial (typo fix, config update)"
+      effort: medium
       tags: [review, quality]
       context:
         default: fork

data/handbook/workflow-instructions/review/run.wf.md

@@ -42,7 +42,7 @@ ace-review --preset $1 --auto-execute
 ace-review --subject "$2" --auto-execute
 
 # File pattern review (NOTE: files: prefix is REQUIRED)
-ace-review --preset spec --subject "files:.ace-taskflow/**/*.md" --auto-execute
+ace-review --preset spec --subject "files:.ace-task/**/*.md" --auto-execute
 
 # Multiple subjects merge automatically
 ace-review --subject pr:76 --subject files:CHANGELOG.md --auto-execute

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

@@ -1,161 +1,34 @@
 # frozen_string_literal: true
 
+require "ace/llm"
+
 module Ace
   module Review
     module Atoms
-      # Pure function for resolving model context limits
-      #
-      # Maps model names to their context window sizes. Handles provider prefixes
-      # (google:, anthropic:, openai:) and uses pattern matching for model families.
-      #
-      # Resolution order:
-      # 1. ace-llm provider config (context_limit in providers/*.yml)
-      # 2. Hardcoded pattern matching (MODEL_LIMITS)
-      # 3. Conservative default for unknown models
-      #
-      # @example Basic usage
-      #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
-      #   #=> 1_000_000
-      #
-      # @example Without provider prefix
-      #   ContextLimitResolver.resolve("claude-3-sonnet")
-      #   #=> 200_000
+      # Review-local wrapper around ace-llm's resolved model limit lookup.
       module ContextLimitResolver
-        # Conservative default for unknown models
-        DEFAULT_LIMIT = 200_000
-
-        # Model patterns and their context limits (fallback when ace-llm config unavailable)
-        # Order matters - first match wins
-        # Patterns use regex for flexible matching
-        MODEL_LIMITS = [
-          # Gemini models
-          {pattern: /gemini-1\.5-pro/i, limit: 2_000_000},
-          {pattern: /gemini-1\.5-flash/i, limit: 1_000_000},
-          {pattern: /gemini-2\.5-pro/i, limit: 1_000_000},
-          {pattern: /gemini-2\.5-flash/i, limit: 1_000_000},
-          {pattern: /gemini-2\.0/i, limit: 1_000_000},
-          # Fallback for any other gemini model
-          {pattern: /gemini/i, limit: 1_000_000},
-
-          # Claude models (all variants: opus, sonnet, haiku)
-          {pattern: /claude.*opus/i, limit: 1_000_000},
-          {pattern: /claude.*sonnet/i, limit: 1_000_000},
-          {pattern: /claude.*haiku/i, limit: 1_000_000},
-          # Fallback for any other claude model
-          {pattern: /claude/i, limit: 1_000_000},
+        DEFAULT_LIMIT = Ace::LLM::Molecules::ModelLimitResolver::DEFAULT_CONTEXT_LIMIT
 
-          # OpenAI models
-          {pattern: /gpt-5\.\d/i, limit: 1_050_000},
-          {pattern: /o4-/i, limit: 1_050_000},
-          {pattern: /gpt-4o/i, limit: 128_000},
-          {pattern: /gpt-4-turbo/i, limit: 128_000},
-          {pattern: /gpt-4-32k/i, limit: 32_768},
-          {pattern: /gpt-4-\d+-preview/i, limit: 128_000}, # gpt-4-1106-preview, gpt-4-0125-preview
-          {pattern: /gpt-4-\d+$/i, limit: 8_192}, # legacy gpt-4-0613, etc.
-          {pattern: /gpt-4$/i, limit: 8_192}, # base gpt-4 model
-          {pattern: /o1-/i, limit: 200_000},
-          {pattern: /o3-/i, limit: 200_000}
-        ].freeze
-
-        # Resolve context limit for a model
-        #
-        # Resolution order:
-        # 1. ace-llm provider config (if available and provider specified)
-        # 2. Hardcoded pattern matching
-        # 3. Default limit
-        #
-        # @param model_name [String, nil] Model identifier, optionally with provider prefix
-        # @return [Integer] Context limit in tokens
-        #
-        # @example With provider prefix
-        #   ContextLimitResolver.resolve("google:gemini-2.5-pro")
-        #   #=> 1_000_000
-        #
-        # @example Without provider prefix
-        #   ContextLimitResolver.resolve("claude-3-opus")
-        #   #=> 200_000
-        #
-        # @example Unknown model
-        #   ContextLimitResolver.resolve("unknown-model")
-        #   #=> 128_000
         def self.resolve(model_name)
-          return DEFAULT_LIMIT if model_name.nil? || model_name.empty?
-
-          # Try to get limit from ace-llm provider config first
-          limit = load_from_ace_llm(model_name)
-          return limit if limit
-
-          # Fall back to hardcoded pattern matching
-          normalized = strip_provider_prefix(model_name)
-          match = MODEL_LIMITS.find { |entry| normalized.match?(entry[:pattern]) }
-          match ? match[:limit] : DEFAULT_LIMIT
+          resolve_details(model_name).context_limit
         end
 
-        # Get the default limit for unknown models
-        #
-        # @return [Integer] Default context limit
-        def self.default_limit
-          DEFAULT_LIMIT
-        end
-
-        # Load context limit from ace-llm provider configuration
-        #
-        # @param model_name [String] Model identifier with provider prefix
-        # @return [Integer, nil] Context limit from config, or nil if not found
-        def self.load_from_ace_llm(model_name)
-          # Extract provider prefix (e.g., "google" from "google:gemini-2.5-pro")
-          return nil unless model_name.include?(":")
-
-          provider = model_name.split(":").first
-          return nil if provider.nil? || provider.empty?
-
-          # Try to load provider config via ace-llm
-          config = load_provider_config(provider)
-          return nil unless config
-
-          # Get context_limit from provider config
-          limit = config["context_limit"]
-          limit.is_a?(Integer) ? limit : nil
+        def self.resolve_details(model_name)
+          Ace::LLM::Molecules::ModelLimitResolver.resolve(model_name)
         rescue
-          nil # Fall back to hardcoded on any error
-        end
-        private_class_method :load_from_ace_llm
-
-        # Load provider configuration from ace-llm
-        #
-        # @param provider [String] Provider name (e.g., "google", "anthropic")
-        # @return [Hash, nil] Provider config hash or nil
-        def self.load_provider_config(provider)
-          # Try to use ace-llm's config loader if available
-          return nil unless defined?(Ace::LLM::Molecules::ConfigLoader)
-
-          resolver = Ace::Support::Config.create(
-            config_dir: ".ace",
-            defaults_dir: ".ace-defaults",
-            gem_path: Ace::LLM::Molecules::ConfigLoader.gem_root
+          Ace::LLM::Molecules::ModelLimitResolver::ResolveResult.new(
+            provider: nil,
+            model: nil,
+            context_limit: DEFAULT_LIMIT,
+            output_limit: nil,
+            source: :fallback,
+            original_target: model_name.to_s
           )
-
-          config = resolver.resolve_namespace("llm", filename: "providers/#{provider}")
-          config.to_h
-        rescue
-          nil
         end
-        private_class_method :load_provider_config
 
-        # Strip provider prefix from model name
-        #
-        # @param model_name [String] Model identifier
-        # @return [String] Model name without provider prefix
-        #
-        # @example
-        #   strip_provider_prefix("google:gemini-2.5-pro")
-        #   #=> "gemini-2.5-pro"
-        def self.strip_provider_prefix(model_name)
-          # Common provider prefixes
-          model_name.sub(/\A(google|anthropic|openai|codex|cli):/, "")
+        def self.default_limit
+          DEFAULT_LIMIT
         end
-
-        private_class_method :strip_provider_prefix
       end
     end
   end

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

@@ -26,6 +26,97 @@ module Ace
       #   result[:items]   #=> [FeedbackItem, ...] (with reviewers arrays)
       #
       class FeedbackSynthesizer
+        # Cached system prompt and prompt-path lookups to avoid repeated
+        # shell/file reads during test and command-heavy runs.
+        FALLBACK_SYSTEM_PROMPT = <<~PROMPT.freeze
+          Synthesize feedback from code review reports into unique findings.
+
+          For each unique issue found:
+          1. Track which reviewers identified it (by their model names)
+          2. Merge file references from all sources
+          3. Use the most comprehensive description
+          4. Mark consensus=true if 3+ reviewers agree
+
+          Return valid JSON with this schema:
+          {
+            "findings": [
+              {
+                "title": "Short title (max 60 chars)",
+                "files": ["path/file.rb:10-20"],
+                "reviewers": ["gemini-2.5-flash", "claude-3.5-sonnet"],
+                "consensus": false,
+                "priority": "high|medium|low|critical",
+                "finding": "Description of the issue",
+                "context": "Why this matters"
+              }
+            ]
+          }
+
+          IMPORTANT:
+          - When only one report: extract all findings as-is with that reviewer
+          - When multiple reports: deduplicate findings that describe the same issue
+          - When multiple reviewers find the same issue, list ALL of them in reviewers array
+          - Merge file arrays from all sources for each finding
+          - Return ONLY the JSON, no markdown code fences
+        PROMPT
+
+        class << self
+          def system_prompt(prompt_name)
+            system_prompt_cache_mutex.synchronize do
+              system_prompt_cache.fetch(prompt_name) do
+                prompt_path = resolve_prompt_path_cached(prompt_name)
+
+                if prompt_path && File.exist?(prompt_path)
+                  system_prompt_cache[prompt_name] = File.read(prompt_path)
+                else
+                  system_prompt_cache[prompt_name] = FALLBACK_SYSTEM_PROMPT
+                end
+              end
+            end
+          end
+
+          def resolve_prompt_path_cached(prompt_name)
+            prompt_path_cache[prompt_name] ||= begin
+              nav_result = begin
+                `ace-nav prompt://#{prompt_name} 2>/dev/null`.strip
+              rescue
+                ""
+              end
+
+              return nav_result unless nav_result.empty?
+
+              File.join(__dir__, "../../../../handbook/prompts", prompt_name)
+            end
+          end
+
+          def clear_prompt_cache!
+            system_prompt_cache_mutex.synchronize do
+              @system_prompt_cache = {}
+            end
+            prompt_path_cache_mutex.synchronize do
+              @prompt_path_cache = {}
+            end
+          end
+
+          private
+
+          def system_prompt_cache
+            @system_prompt_cache ||= {}
+          end
+
+          def prompt_path_cache
+            @prompt_path_cache ||= {}
+          end
+
+          def system_prompt_cache_mutex
+            @system_prompt_cache_mutex ||= Mutex.new
+          end
+
+          def prompt_path_cache_mutex
+            @prompt_path_cache_mutex ||= Mutex.new
+          end
+        end
+
         # Maximum combined report size before truncation (characters)
         MAX_COMBINED_SIZE = 200_000
 
@@ -138,51 +229,14 @@ module Ace
         #
         # @return [String] System prompt content
         def load_system_prompt
-          prompt_name = "synthesize-feedback.system.md"
-          prompt_path = resolve_prompt_path(prompt_name)
-
-          if File.exist?(prompt_path)
-            File.read(prompt_path)
-          else
-            fallback_synthesis_prompt
-          end
+          self.class.system_prompt("synthesize-feedback.system.md")
         end
 
         # Fallback synthesis prompt (used when prompt file not found)
         #
         # @return [String] Basic synthesis prompt
         def fallback_synthesis_prompt
-          <<~PROMPT
-            Synthesize feedback from code review reports into unique findings.
-
-            For each unique issue found:
-            1. Track which reviewers identified it (by their model names)
-            2. Merge file references from all sources
-            3. Use the most comprehensive description
-            4. Mark consensus=true if 3+ reviewers agree
-
-            Return valid JSON with this schema:
-            {
-              "findings": [
-                {
-                  "title": "Short title (max 60 chars)",
-                  "files": ["path/file.rb:10-20"],
-                  "reviewers": ["gemini-2.5-flash", "claude-3.5-sonnet"],
-                  "consensus": false,
-                  "priority": "high|medium|low|critical",
-                  "finding": "Description of the issue",
-                  "context": "Why this matters"
-                }
-              ]
-            }
-
-            IMPORTANT:
-            - When only one report: extract all findings as-is with that reviewer
-            - When multiple reports: deduplicate findings that describe the same issue
-            - When multiple reviewers find the same issue, list ALL of them in reviewers array
-            - Merge file arrays from all sources for each finding
-            - Return ONLY the JSON, no markdown code fences
-          PROMPT
+          FALLBACK_SYSTEM_PROMPT
         end
 
         # Build user prompt for report synthesis
@@ -522,16 +576,7 @@ module Ace
         # @param prompt_name [String] Prompt filename
         # @return [String] Resolved file path
         def resolve_prompt_path(prompt_name)
-          # Try ace-nav first if available
-          nav_result = begin
-            `ace-nav prompt://#{prompt_name} 2>/dev/null`.strip
-          rescue
-            ""
-          end
-          return nav_result unless nav_result.empty?
-
-          # Fallback to direct path
-          File.join(__dir__, "../../../../handbook/prompts", prompt_name)
+          self.class.resolve_prompt_path_cached(prompt_name)
         end
 
         # Get default synthesis model from config

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

@@ -53,7 +53,8 @@ module Ace
               error: "Failed to post comment: #{result[:stderr]}"
             }
           end
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           raise
         rescue => e
           {
@@ -68,7 +69,7 @@ module Ace
         # @return [Hash] Result with :success or :error
         def self.check_pr_state(gh_format)
           # Fetch PR metadata
-          result = Ace::Review::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Molecules::GhCliExecutor.execute(
             "pr",
             ["view", gh_format, "--json", "state,number"]
           )
@@ -169,7 +170,7 @@ module Ace
             file.flush
 
             # Post using gh pr comment
-            Ace::Review::Molecules::GhCliExecutor.execute(
+            Ace::Git::Molecules::GhCliExecutor.execute(
               "pr",
               ["comment", gh_format, "--body-file", file.path]
             )

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

@@ -34,7 +34,7 @@ module Ace
           timeout = options[:timeout] || 30
 
           # Post comment using gh CLI
-          result = Ace::Review::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Molecules::GhCliExecutor.execute(
             "pr",
             ["comment", gh_format, "--body", body],
             timeout: timeout
@@ -54,7 +54,8 @@ module Ace
               error: "Failed to post reply: #{result[:stderr]}"
             }
           end
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           raise
         rescue => e
           {
@@ -91,7 +92,7 @@ module Ace
           mutation = build_resolve_thread_mutation(thread_id)
 
           # Execute via gh api graphql
-          result = Ace::Review::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Molecules::GhCliExecutor.execute(
             "api",
             ["graphql", "-f", "query=#{mutation}"],
             timeout: timeout
@@ -118,7 +119,8 @@ module Ace
               error: "Failed to resolve thread: #{result[:stderr]}"
             }
           end
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           raise
         rescue => e
           {

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

@@ -82,7 +82,7 @@ module Ace
           fields = "comments,reviews,number,title,author"
 
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Review::Molecules::GhCliExecutor.execute("pr", ["view", gh_format, "--json", fields], timeout: timeout)
+            Ace::Git::Molecules::GhCliExecutor.execute("pr", ["view", gh_format, "--json", fields], timeout: timeout)
           end
 
           if result[:success]
@@ -116,7 +116,8 @@ module Ace
             success: false,
             error: "Failed to parse PR comments: #{e.message}"
           }
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           raise
         rescue => e
           {
@@ -250,7 +251,7 @@ module Ace
 
           # Execute GraphQL query
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Review::Molecules::GhCliExecutor.execute(
+            Ace::Git::Molecules::GhCliExecutor.execute(
               "api",
               [
                 "graphql",
@@ -382,7 +383,7 @@ module Ace
         # @return [String, nil] "owner/name" format or nil if not a GitHub repo
         def self.discover_repo_from_remote(options = {})
           timeout = options[:timeout] || 10
-          result = Ace::Review::Molecules::GhCliExecutor.execute(
+          result = Ace::Git::Molecules::GhCliExecutor.execute(
             "repo",
             ["view", "--json", "owner,name"],
             timeout: timeout

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

@@ -26,7 +26,7 @@ module Ace
 
           # Fetch diff with retry logic
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Review::Molecules::GhCliExecutor.execute("pr", ["diff", gh_format], timeout: timeout)
+            Ace::Git::Molecules::GhCliExecutor.execute("pr", ["diff", gh_format], timeout: timeout)
           end
 
           if result[:success]
@@ -42,7 +42,8 @@ module Ace
         rescue Ace::Review::Errors::DiffTooLargeError
           # Fall back to local git diff when GitHub API rejects large diffs
           fetch_local_diff_fallback(pr_identifier, options)
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           # Re-raise authentication and installation errors
           raise
         rescue => e
@@ -70,7 +71,7 @@ module Ace
           fields = "number,state,isDraft,title,body,author,headRefName,baseRefName,url"
 
           result = Ace::Review::Atoms::RetryWithBackoff.execute(options) do
-            Ace::Review::Molecules::GhCliExecutor.execute("pr", ["view", gh_format, "--json", fields], timeout: timeout)
+            Ace::Git::Molecules::GhCliExecutor.execute("pr", ["view", gh_format, "--json", fields], timeout: timeout)
           end
 
           if result[:success]
@@ -89,7 +90,8 @@ module Ace
             success: false,
             error: "Failed to parse PR metadata: #{e.message}"
           }
-        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError
+        rescue Ace::Review::Errors::GhCliNotInstalledError, Ace::Review::Errors::GhAuthenticationError,
+          Ace::Git::GhNotInstalledError, Ace::Git::GhAuthenticationError
           raise
         rescue => e
           {

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

@@ -67,12 +67,19 @@ module Ace
           total_chars = (system_prompt&.length || 0) + (user_prompt&.length || 0)
           estimated_tokens = total_chars / 4  # Rough estimate: 4 chars per token
 
-          context_limit = Ace::Review::Atoms::ContextLimitResolver.resolve(model)
+          limit_details = Ace::Review::Atoms::ContextLimitResolver.resolve_details(model)
+          context_limit = limit_details.context_limit
           threshold = (context_limit * PROMPT_SIZE_WARNING_RATIO).to_i
           return unless estimated_tokens > threshold
 
+          display_model = if limit_details.full_model && limit_details.full_model != model
+            "#{model} -> #{limit_details.full_model}"
+          else
+            model
+          end
+
           warn "Warning: Prompt size (~#{estimated_tokens.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens) " \
-               "may exceed #{model} context limit (#{context_limit.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens)"
+               "may exceed #{display_model} context limit (#{context_limit.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens)"
         end
 
         # Check if Ruby API is available

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

@@ -14,8 +14,8 @@ module Ace
         # Default timeout for LLM queries (5 minutes)
         DEFAULT_LLM_TIMEOUT = 300
 
-        # Warning threshold: 80% of typical 1M context window
-        PROMPT_SIZE_WARNING_THRESHOLD = 800_000
+        # Warning threshold: 80% of the smallest resolved context window in the batch
+        PROMPT_SIZE_WARNING_RATIO = LlmExecutor::PROMPT_SIZE_WARNING_RATIO
 
         def initialize(max_concurrent: nil, llm_timeout: nil)
           # Read from config, fallback to default of 3, clamp to minimum 1
@@ -266,7 +266,14 @@ module Ace
           total_chars = (system_prompt&.length || 0) + (user_prompt&.length || 0)
           estimated_tokens = total_chars / 4  # Rough estimate: 4 chars per token
 
-          return unless estimated_tokens > PROMPT_SIZE_WARNING_THRESHOLD
+          resolved_limits = models.map do |model|
+            Atoms::ContextLimitResolver.resolve_details(model)
+          end
+          min_context_limit = resolved_limits.map(&:context_limit).compact.min
+          return if min_context_limit.nil?
+
+          threshold = (min_context_limit * PROMPT_SIZE_WARNING_RATIO).to_i
+          return unless estimated_tokens > threshold
 
           model_list = models.join(", ")
           warn "Warning: Prompt size (~#{estimated_tokens.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')} tokens) " \

data/lib/ace/review/molecules/strategies/adaptive_strategy.rb

@@ -70,7 +70,7 @@ module Ace
             explicit_limit = context[:model_context_limit] || context["model_context_limit"]
 
             # Resolve model context limit
-            model_limit = explicit_limit || Atoms::ContextLimitResolver.resolve(model)
+            model_limit = explicit_limit || Atoms::ContextLimitResolver.resolve_details(model).context_limit
 
             # Select and delegate to appropriate strategy
             selected = select_strategy(subject, model_limit, model)

data/lib/ace/review/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Review
-    VERSION = '0.51.7'
+    VERSION = '0.53.6'
   end
 end

data/lib/ace/review.rb

@@ -37,7 +37,6 @@ require_relative "review/molecules/preset_manager"
 require_relative "review/molecules/prompt_composer"
 require_relative "review/molecules/nav_prompt_resolver"
 require_relative "review/molecules/subject_extractor"
-require_relative "review/molecules/gh_cli_executor"
 require_relative "review/molecules/gh_pr_fetcher"
 require_relative "review/molecules/gh_pr_comment_fetcher"
 require_relative "review/molecules/gh_comment_poster"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-review
 version: !ruby/object:Gem::Version
-  version: 0.51.7
+  version: 0.53.6
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -300,7 +300,6 @@ files:
 - lib/ace/review/molecules/feedback_file_reader.rb
 - lib/ace/review/molecules/feedback_file_writer.rb
 - lib/ace/review/molecules/feedback_synthesizer.rb
-- lib/ace/review/molecules/gh_cli_executor.rb
 - lib/ace/review/molecules/gh_comment_poster.rb
 - lib/ace/review/molecules/gh_comment_resolver.rb
 - lib/ace/review/molecules/gh_pr_comment_fetcher.rb

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

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "timeout"
-
-module Ace
-  module Review
-    module Molecules
-      # Safely execute gh CLI commands with error handling
-      class GhCliExecutor
-        # Default timeout for gh CLI operations
-        DEFAULT_GH_TIMEOUT = 30
-
-        # Execute a gh CLI command
-        #
-        # @param subcommand [String] The gh subcommand (e.g., "pr", "api")
-        # @param args [Array<String>] Arguments to pass to the subcommand
-        # @param options [Hash] Additional options
-        # @option options [Integer] :timeout Timeout in seconds (default: from config or 30)
-        # @return [Hash] Result with :success, :stdout, :stderr, :exit_code
-        def self.execute(subcommand, args = [], options = {})
-          check_installed
-
-          timeout_seconds = options[:timeout] ||
-            Ace::Review.get("defaults", "gh_timeout") ||
-            DEFAULT_GH_TIMEOUT
-          command = ["gh", subcommand] + args
-
-          run_command(command, timeout_seconds)
-        rescue Timeout::Error
-          raise Ace::Review::Errors::GhNetworkError, "gh command timed out after #{timeout_seconds} seconds"
-        end
-
-        # Check if gh CLI is installed
-        #
-        # @return [Boolean] true if installed
-        # @raise [GhCliNotInstalledError] if not installed
-        def self.check_installed
-          result = execute_simple("--version")
-          result[:success]
-        rescue Ace::Review::Errors::GhCliNotInstalledError
-          raise
-        end
-
-        # Check if user is authenticated with GitHub
-        #
-        # @return [Hash] Auth status with :authenticated, :username
-        # @raise [GhAuthenticationError] if not authenticated
-        def self.check_authenticated
-          result = execute_simple("auth", ["status"])
-
-          if result[:success]
-            # Extract username from stderr (gh auth status outputs to stderr)
-            username = extract_username(result[:stderr])
-            {
-              authenticated: true,
-              username: username
-            }
-          else
-            raise Ace::Review::Errors::GhAuthenticationError
-          end
-        end
-
-        # Default timeout for simple operations
-        DEFAULT_SIMPLE_TIMEOUT = 10
-
-        # Execute a simple gh command without error checking
-        # Used internally to avoid infinite recursion in check_installed
-        #
-        # @param command [String] The gh subcommand
-        # @param args [Array<String>] Arguments
-        # @param timeout_seconds [Integer] Timeout in seconds (default: from config or 10)
-        # @return [Hash] Result hash
-        def self.execute_simple(command, args = [], timeout_seconds = nil)
-          timeout_seconds ||= Ace::Review.get("defaults", "gh_simple_timeout") || DEFAULT_SIMPLE_TIMEOUT
-          cmd = ["gh", command] + args
-          run_command(cmd, timeout_seconds)
-        rescue Timeout::Error
-          {
-            success: false,
-            stdout: "",
-            stderr: "Command timed out",
-            exit_code: 1
-          }
-        end
-
-        # Extract username from gh auth status output
-        #
-        # @param output [String] Output from gh auth status
-        # @return [String, nil] Username if found
-        def self.extract_username(output)
-          # gh auth status output format: "✓ Logged in to github.com as username ..."
-          match = output.match(/Logged in to .+ as (\S+)/)
-          match ? match[1] : nil
-        end
-
-        # Execute a command with timeout and error handling
-        # Private helper to reduce duplication between execute and execute_simple
-        #
-        # @param command [Array<String>] Full command array including "gh"
-        # @param timeout_seconds [Integer] Timeout in seconds
-        # @return [Hash] Result with :success, :stdout, :stderr, :exit_code
-        # @raise [GhCliNotInstalledError] if gh is not installed
-        # @raise [Timeout::Error] if command times out (caller should handle)
-        def self.run_command(command, timeout_seconds)
-          stdout_str, stderr_str, status = Timeout.timeout(timeout_seconds) do
-            Open3.capture3(*command)
-          end
-
-          {
-            success: status.success?,
-            stdout: stdout_str,
-            stderr: stderr_str,
-            exit_code: status.exitstatus
-          }
-        rescue Errno::ENOENT
-          raise Ace::Review::Errors::GhCliNotInstalledError
-        end
-
-        private_class_method :execute_simple, :extract_username, :run_command
-      end
-    end
-  end
-end