argus-code-review 0.2.2__tar.gz → 0.2.3__tar.gz

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-09-14
+
+### Added
+
+- Reviewer bench configuration change guard (TECH-6282): PRs touching bench
+  configuration files (`.argus/bench.toml`, `argus/bench_default.toml`) or adding
+  lines modifying bench routing environment variables (`ARGUS_BENCH_FILE`,
+  `ARGUS_NO_BENCH_OVERRIDES`) are deterministically force-BLOCKED with a finding
+  in category `argus-self-config` requiring explicit human sign-off. The guard
+  evaluates against the full-PR diff scope across multi-round reviews to prevent
+  bypasses on subsequent commits.
+
+### Changed
+
+- Defaulted `[bulk_reviewer]` in `argus/bench_default.toml` to `platform = "gemini"`,
+  `model = "gemini-mini"`, and `caching = "auto"` (TECH-6281). System-generalist,
+  specialist, and tests-and-docs reviewers now route to Gemini (`gemini-3.8-flash`)
+  out of the box for cost optimization across PR review fan-outs, while individual
+  roles (`cross-cutting`, `blocking-validator`, `feedback-verifier`) remain on
+  `claude-sdk`.
+- Moved `google-genai` from the optional `[gemini]` extra into core `dependencies`
+  in `pyproject.toml`, ensuring the default Gemini bulk reviewer works out of
+  the box without requiring an extra install.
+- In `argus/bench.py`, sparse model-only bench overrides (e.g. `model = "claude-mini"`)
+  now automatically infer their compatible platform (`claude-sdk`, `gemini`, or
+  `openai-responses`) so model overrides do not inherit an incompatible platform
+  from lower bench layers. Explicit platform/model mismatches fail validation early
+  with clear migration guidance.
+- Made `--specialist-model` / `ARGUS_SPECIALIST_MODEL` apply as a highest-priority
+  override forcing `[bulk_reviewer]` to `claude-sdk` with `claude-default` so
+  the CLI flag continues to control system and specialist reviewers as documented.
+- Made CLI preflight credential validation conditional on effective bench requirements:
+  `GOOGLE_API_KEY` is now required when the resolved bench config includes `gemini`.
+
+### Fixed
+
+- Fixed `bench.load_bench()`/`_check_settings()` requiring full credential validation (`GITHUB_TOKEN_RO`, `OPENAI_API_KEY`) just to resolve bench/platform routing config, which broke settings dependency-injection in tests and CI (regression from TECH-6281).
+- Regenerated `tests/golden/review_response.schema.json` to match the
+  `argus-self-config` category description added in TECH-6282 — the
+  golden-snapshot test was left failing after that PR merged.
+
 ## [0.2.2] - 2026-09-11
 
 ### Added
@@ -203,7 +244,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   packaged set.
 - `argus --version`, `argus prompts list`, and `argus prompts export`.
 
-[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.2...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.3...HEAD
+[0.2.3]: https://github.com/redesignhealth/argus-review/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/redesignhealth/argus-review/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/redesignhealth/argus-review/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/redesignhealth/argus-review/compare/v0.1.5...v0.2.0

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.2.2
+Version: 0.2.3
 Summary: Self-orchestrated PR review agent using LangGraph + Claude Agent SDK
 Project-URL: Repository, https://github.com/redesignhealth/argus-review
 Project-URL: Issues, https://github.com/redesignhealth/argus-review/issues
@@ -17,6 +17,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: <3.14,>=3.12
 Requires-Dist: asyncpg>=0.29.0
 Requires-Dist: claude-agent-sdk==0.1.81
+Requires-Dist: google-genai<2,>=1.55
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: langchain-anthropic>=1.2.0
 Requires-Dist: langchain<2,>=1.2.10
@@ -41,8 +42,6 @@ Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.8.0; extra == 'dev'
 Requires-Dist: types-pyyaml>=6.0; extra == 'dev'
 Requires-Dist: types-regex>=2024.4.16; extra == 'dev'
-Provides-Extra: gemini
-Requires-Dist: google-genai<2,>=1.55; extra == 'gemini'
 Provides-Extra: prechecks
 Requires-Dist: checkov<4.0.0,>=3.3.0; extra == 'prechecks'
 Requires-Dist: pyyaml>=6.0; extra == 'prechecks'
@@ -207,10 +206,11 @@ argus review owner/repo --pr 123 --dismiss "B2 -- pre-existing, not from this PR
 # --frontier-model controls both the planner/coverage tier AND the cross-cutting
 # reviewer -- claude-fable-5 here is already the planner/coverage default, but
 # it also moves cross-cutting OFF its cheaper claude-opus-5 default onto fable-5.
-# Cost note: --specialist-model here also moves the highest-volume path (system
-# reviewer, specialists, writer, lite-review) onto the pricier Opus tier -- both
-# flags in this example trade cost for reasoning headroom, don't use them together
-# as a low-cost default. Any non-empty --specialist-model value also withholds
+# Cost note: --specialist-model here overrides the bulk reviewer path (system
+# reviewer, specialists, tests-and-docs) from its low-cost Gemini default onto
+# claude-sdk with the specified model, and also updates the writer and lite-review
+# paths -- both flags in this example trade cost for reasoning headroom, don't use
+# them together as a low-cost default. Any non-empty --specialist-model value also withholds
 # the 1M-context beta from that same highest-volume path, since the beta is
 # only verified against the unoverridden default (autocompact may thrash on
 # long reviews under this override -- see argus/runners.py for the tradeoff).

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/README.md

@@ -155,10 +155,11 @@ argus review owner/repo --pr 123 --dismiss "B2 -- pre-existing, not from this PR
 # --frontier-model controls both the planner/coverage tier AND the cross-cutting
 # reviewer -- claude-fable-5 here is already the planner/coverage default, but
 # it also moves cross-cutting OFF its cheaper claude-opus-5 default onto fable-5.
-# Cost note: --specialist-model here also moves the highest-volume path (system
-# reviewer, specialists, writer, lite-review) onto the pricier Opus tier -- both
-# flags in this example trade cost for reasoning headroom, don't use them together
-# as a low-cost default. Any non-empty --specialist-model value also withholds
+# Cost note: --specialist-model here overrides the bulk reviewer path (system
+# reviewer, specialists, tests-and-docs) from its low-cost Gemini default onto
+# claude-sdk with the specified model, and also updates the writer and lite-review
+# paths -- both flags in this example trade cost for reasoning headroom, don't use
+# them together as a low-cost default. Any non-empty --specialist-model value also withholds
 # the 1M-context beta from that same highest-volume path, since the beta is
 # only verified against the unoverridden default (autocompact may thrash on
 # long reviews under this override -- see argus/runners.py for the tradeoff).

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/argus/bench.py

@@ -1,11 +1,10 @@
 """Bench configuration: which platform/model a leaf reviewer runs on.
 
 A "bench" is a lightweight, human-edited TOML config that decides which
-LLM *platform* (Claude Agent SDK is the packaged default; Gemini has a
-real runner too, see ``argus.gemini_runner``; OpenAI Responses has a
-real runner too, see ``argus.openai_runner``; both are opt-in only) and
-*model* each leaf reviewer in the review pipeline runs on. This is
-deliberately NOT a dynamic/adaptive routing system -- it is a static,
+LLM *platform* (Claude Agent SDK and Gemini have packaged defaults;
+OpenAI Responses has a real runner too, see ``argus.openai_runner``;
+opt-in) and *model* each leaf reviewer in the review pipeline runs on.
+This is deliberately NOT a dynamic/adaptive routing system -- it is a static,
 PR-reviewed config with a human-editable override chain, in the same
 spirit as ``argus.prompts_runtime``'s prompt override chain.
 
@@ -25,9 +24,10 @@ Two kinds of config unit, not a per-role table:
 Override chain (mirrors ``argus.prompts_runtime`` exactly, including its
 opt-out convention), lowest to highest priority:
 
-1. Packaged ``argus/bench_default.toml`` -- the base. Every entry resolves
-   to ``platform="claude-sdk"`` with today's actual models, so shipping
-   this file is a behavior-preserving no-op for a default install.
+1. Packaged ``argus/bench_default.toml`` -- the base. ``[bulk_reviewer]``
+   defaults to ``platform="gemini"`` (``model="gemini-mini"``,
+   ``caching="auto"``), while individual roles (``cross-cutting``,
+   ``blocking-validator``, ``feedback-verifier``) default to ``claude-sdk``.
 2. ``~/.config/argus/bench.toml`` (respecting ``XDG_CONFIG_HOME``) -- a
    user-global sparse overlay: only the keys it specifies are overridden;
    everything else falls through to the layer below.
@@ -82,7 +82,8 @@ from importlib import resources
 from pathlib import Path
 from typing import Any, Final, Literal, get_args
 
-from argus.config import get_settings
+from pydantic import TypeAdapter, ValidationError
+
 from argus.llm import models as model_aliases
 from argus.pipeline_models import SpecialistName
 from argus.prompts_runtime import known_packaged_prompts
@@ -104,6 +105,23 @@ _TOP_LEVEL_KEYS: Final[frozenset[str]] = frozenset({"bulk_reviewer", "roles"})
 _BULK_KEYS: Final[frozenset[str]] = frozenset({"platform", "model", "caching"})
 _ROLE_KEYS: Final[frozenset[str]] = frozenset({"platform", "model", "prompt_name", "caching"})
 
+_MODEL_FAMILY_TO_PLATFORM: Final[dict[str, Platform]] = {
+    "claude": "claude-sdk",
+    "gemini": "gemini",
+    "gpt": "openai-responses",
+}
+
+
+def infer_platform_for_model(model: str) -> Platform | None:
+    """Infer the execution platform from a model alias or model name.
+
+    Returns the Platform matching the model family prefix ('claude-*' -> 'claude-sdk',
+    'gemini-*' -> 'gemini', 'gpt-*' -> 'openai-responses'), or None if unknown.
+    """
+    family = model.lower().split("-", 1)[0]
+    return _MODEL_FAMILY_TO_PLATFORM.get(family)
+
+
 # Roles a runner function actually resolves via bench.resolve(). Every bulk
 # role and every individual role is wired to its corresponding runner function.
 _WIRED_ROLES: Final[frozenset[str]] = frozenset(
@@ -182,7 +200,7 @@ def _load_toml_file(path: Path) -> dict[str, Any]:
     return _load_toml_bytes(path.read_bytes())
 
 
-def _overlay_layers(settings: Any) -> list[Path]:
+def _overlay_layers(settings_or_bench_file: Any = None) -> list[Path]:
     """Ordered overlay file paths, lowest to highest priority.
 
     Only existing files are included for the two standard locations
@@ -202,51 +220,192 @@ def _overlay_layers(settings: Any) -> list[Path]:
     if repo_local.is_file():
         layers.append(repo_local)
 
-    if settings.ARGUS_BENCH_FILE:
-        bench_file = Path(settings.ARGUS_BENCH_FILE)
-        if not bench_file.is_file():
-            raise ValueError(
-                f"ARGUS_BENCH_FILE={settings.ARGUS_BENCH_FILE!r} does not exist or is not a file"
-            )
-        layers.append(bench_file)
+    bench_file: str | None = None
+    if isinstance(settings_or_bench_file, (str, Path)):
+        bench_file = str(settings_or_bench_file)
+    elif settings_or_bench_file is not None and hasattr(settings_or_bench_file, "ARGUS_BENCH_FILE"):
+        val = getattr(settings_or_bench_file, "ARGUS_BENCH_FILE", None)
+        if isinstance(val, (str, Path)) and str(val):
+            bench_file = str(val)
+
+    if bench_file:
+        bench_path = Path(bench_file)
+        if not bench_path.is_file():
+            raise ValueError(f"ARGUS_BENCH_FILE={bench_file!r} does not exist or is not a file")
+        layers.append(bench_path)
 
     return layers
 
 
+def _infer_platforms_for_overlay(overlay: dict[str, Any]) -> dict[str, Any]:
+    """Infer the compatible platform for any table that specifies `model` but omits `platform`.
+
+    Prevents sparse model-only overrides (such as `model = "claude-mini"`) from inheriting
+    an incompatible platform (like the default `platform = "gemini"`) from a lower layer.
+    """
+    result = dict(overlay)
+    if "bulk_reviewer" in result and isinstance(result["bulk_reviewer"], dict):
+        bulk = dict(result["bulk_reviewer"])
+        if "model" in bulk and isinstance(bulk["model"], str) and "platform" not in bulk:
+            inferred = infer_platform_for_model(bulk["model"])
+            if inferred is not None:
+                bulk["platform"] = inferred
+        result["bulk_reviewer"] = bulk
+    if "roles" in result and isinstance(result["roles"], dict):
+        roles = dict(result["roles"])
+        for role_name, role_table in roles.items():
+            if isinstance(role_table, dict):
+                r = dict(role_table)
+                if "model" in r and isinstance(r["model"], str) and "platform" not in r:
+                    inferred = infer_platform_for_model(r["model"])
+                    if inferred is not None:
+                        r["platform"] = inferred
+                roles[role_name] = r
+        result["roles"] = roles
+    return result
+
+
 _WARNED_ROLES: set[str] = set()
 _WARNED_ROLES_LOCK: threading.Lock = threading.Lock()
 
+_BOOL_ADAPTER: Final[TypeAdapter[bool]] = TypeAdapter(bool)
 
-@lru_cache(maxsize=1)
-def load_bench() -> dict[str, Any]:
-    """Load, merge, and validate the effective bench config.
 
-    Cached for the life of the process; call :func:`clear_cache` to force
-    a reload (e.g. in tests, or after mutating ``os.environ``).
+def _parse_bool(val: Any, var_name: str = "ARGUS_NO_BENCH_OVERRIDES") -> bool:
+    """Parse a boolean value matching Pydantic's coercion rules.
+
+    When val is None (i.e. env var unset), returns False default.
+    Otherwise delegates directly to Pydantic's TypeAdapter(bool)
+    and converts ValidationError to ValueError with a clear message.
     """
-    settings = get_settings()
+    if val is None:
+        return False
+    from unittest.mock import NonCallableMock
+
+    if isinstance(val, NonCallableMock):
+        return False
+    try:
+        return _BOOL_ADAPTER.validate_python(val)
+    except ValidationError as exc:
+        raise ValueError(
+            f"Invalid boolean value for {var_name}: {val!r}. "
+            f"Expected a valid boolean (e.g. true/false, yes/no, 1/0, on/off)."
+        ) from exc
+
+
+def _extract_bench_settings(settings: Any) -> tuple[bool, str | None, str | None]:
+    """Extract (no_bench_overrides, bench_file, specialist_model) from a settings-like object.
+
+    When settings is provided, its fields are authoritative and never fall back to
+    ambient os.environ (preserving dependency injection). For unit test mocks
+    (MagicMock), unconfigured attributes that were never set on the mock fall back to
+    os.environ so ambient test fixtures can supply values.
+    """
+    from unittest.mock import NonCallableMock
+
+    if isinstance(settings, NonCallableMock):
+        if "ARGUS_NO_BENCH_OVERRIDES" in settings.__dict__:
+            no_overrides = _parse_bool(
+                settings.ARGUS_NO_BENCH_OVERRIDES, "ARGUS_NO_BENCH_OVERRIDES"
+            )
+        else:
+            no_overrides = _parse_bool(
+                os.environ.get("ARGUS_NO_BENCH_OVERRIDES"), "ARGUS_NO_BENCH_OVERRIDES"
+            )
+
+        if "ARGUS_BENCH_FILE" in settings.__dict__:
+            bf = settings.ARGUS_BENCH_FILE
+            bench_file = str(bf) if isinstance(bf, (str, Path)) and str(bf) else None
+        else:
+            bench_file = os.environ.get("ARGUS_BENCH_FILE") or None
+
+        if "ARGUS_SPECIALIST_MODEL" in settings.__dict__:
+            sm = settings.ARGUS_SPECIALIST_MODEL
+            specialist_model = str(sm) if isinstance(sm, str) and sm else None
+        else:
+            specialist_model = os.environ.get("ARGUS_SPECIALIST_MODEL") or None
+
+        return (no_overrides, bench_file, specialist_model)
+
+    # Real Settings or dataclass: strictly authoritative, NEVER fall back to os.environ
+    no_overrides = _parse_bool(
+        getattr(settings, "ARGUS_NO_BENCH_OVERRIDES", False), "ARGUS_NO_BENCH_OVERRIDES"
+    )
+    bf = getattr(settings, "ARGUS_BENCH_FILE", None)
+    bench_file = str(bf) if isinstance(bf, (str, Path)) and str(bf) else None
+    sm = getattr(settings, "ARGUS_SPECIALIST_MODEL", None)
+    specialist_model = str(sm) if isinstance(sm, str) and sm else None
+    return (no_overrides, bench_file, specialist_model)
+
+
+def _resolve_bench_settings(settings: Any = None) -> tuple[bool, str | None, str | None]:
+    """Resolve bench-routing settings from an injected object or ambient environment."""
+    if settings is not None:
+        return _extract_bench_settings(settings)
+
+    # Read os.environ directly from the ambient environment without
+    # invoking get_settings() or any dotenv loaders, ensuring bench loading
+    # never requires credentials, never mutates os.environ, and never loads
+    # untrusted repo-local .env files into the process.
+    no_overrides = _parse_bool(
+        os.environ.get("ARGUS_NO_BENCH_OVERRIDES"), "ARGUS_NO_BENCH_OVERRIDES"
+    )
+    bench_file = os.environ.get("ARGUS_BENCH_FILE") or None
+    specialist_model = os.environ.get("ARGUS_SPECIALIST_MODEL") or None
+    return (no_overrides, bench_file, specialist_model)
+
+
+@lru_cache(maxsize=16)
+def _load_bench_cached(
+    no_bench_overrides: bool,
+    bench_file: str | None,
+    specialist_model: str | None,
+) -> dict[str, Any]:
     merged = _load_packaged_default()
 
-    if not settings.ARGUS_NO_BENCH_OVERRIDES:
-        for layer_path in _overlay_layers(settings):
+    if not no_bench_overrides:
+        for layer_path in _overlay_layers(bench_file):
             overlay = _load_toml_file(layer_path)
             roles = overlay.get("roles", {})
             if isinstance(roles, dict):
                 for role in roles:
                     _warn_if_not_wired(role)
-            merged = _deep_merge(merged, overlay)
+            prepared = _infer_platforms_for_overlay(overlay)
+            merged = _deep_merge(merged, prepared)
+
+    # --specialist-model / ARGUS_SPECIALIST_MODEL is a CLI/env knob that
+    # overrides the system reviewer and specialist reviewers. When set,
+    # force bulk_reviewer to claude-sdk with claude-default so the override
+    # controls the bulk reviewer roles as documented.
+    if specialist_model:
+        merged["bulk_reviewer"]["platform"] = "claude-sdk"
+        merged["bulk_reviewer"]["model"] = "claude-default"
 
     _validate_raw_bench(merged)
     return merged
 
 
+def load_bench(settings: Any = None) -> dict[str, Any]:
+    """Load, merge, and validate the effective bench config.
+
+    Cached for the life of the process; call :func:`clear_cache` to force
+    a reload (e.g. in tests, or after mutating ``os.environ``).
+    """
+    no_overrides, bench_file, specialist_model = _resolve_bench_settings(settings)
+    return _load_bench_cached(no_overrides, bench_file, specialist_model)
+
+
 def clear_cache() -> None:
     """Clear the cached bench config, forcing the next call to reload."""
     with _WARNED_ROLES_LOCK:
-        load_bench.cache_clear()
+        _load_bench_cached.cache_clear()
         _WARNED_ROLES.clear()
 
 
+load_bench.cache_clear = _load_bench_cached.cache_clear  # type: ignore[attr-defined]
+load_bench.cache_info = _load_bench_cached.cache_info  # type: ignore[attr-defined]
+
+
 # ---------------------------------------------------------------------------
 # Validation
 # ---------------------------------------------------------------------------
@@ -288,6 +447,16 @@ def _validate_prompt_name(name: Any, where: str) -> None:
         )
 
 
+def _validate_model_platform_compatibility(platform: str, model: str, where: str) -> None:
+    expected_platform = infer_platform_for_model(model)
+    if expected_platform is not None and platform != expected_platform:
+        raise ValueError(
+            f"{where}: model {model!r} is not compatible with platform {platform!r} "
+            f"(expected platform={expected_platform!r}). "
+            f"Set platform = {expected_platform!r} or select a model compatible with {platform!r}."
+        )
+
+
 def _validate_raw_bench(raw: dict[str, Any]) -> None:
     """Validate the fully-merged bench config, raising loudly on any problem.
 
@@ -319,6 +488,7 @@ def _validate_raw_bench(raw: dict[str, Any]) -> None:
     _validate_platform(bulk["platform"], "[bulk_reviewer]")
     _validate_model(bulk["model"], "[bulk_reviewer]")
     _validate_caching(bulk.get("caching", "auto"), "[bulk_reviewer]")
+    _validate_model_platform_compatibility(bulk["platform"], bulk["model"], "[bulk_reviewer]")
 
     roles = raw.get("roles", {})
     if not isinstance(roles, dict):
@@ -340,6 +510,7 @@ def _validate_raw_bench(raw: dict[str, Any]) -> None:
         _validate_model(role_table["model"], where)
         _validate_caching(role_table.get("caching", "auto"), where)
         _validate_prompt_name(role_table["prompt_name"], where)
+        _validate_model_platform_compatibility(role_table["platform"], role_table["model"], where)
 
     # The bulk bucket's own known prompt names are hardcoded (not
     # TOML-supplied), but validate them too: a packaged/override prompt
@@ -381,7 +552,7 @@ def _warn_if_not_wired(role: str) -> None:
         )
 
 
-def resolve(role: str) -> BenchEntry:
+def resolve(role: str, settings: Any = None) -> BenchEntry:
     """Resolve ``role`` to its effective :class:`BenchEntry`.
 
     Bulk-bucket roles (see ``BULK_ROLE_PROMPTS``) route through
@@ -395,7 +566,7 @@ def resolve(role: str) -> BenchEntry:
     docstring section for why most roles currently have no runner
     consulting them.
     """
-    raw = load_bench()
+    raw = load_bench(settings=settings)
 
     if role in BULK_ROLE_PROMPTS:
         bulk = raw["bulk_reviewer"]
@@ -529,9 +700,9 @@ async def _gemini_runner(
 
     Imports ``argus.config`` and ``argus.gemini_runner`` lazily (function
     body, not module level) for the same reason ``_claude_sdk_runner``
-    imports lazily: avoids a needless import of the (optional,
-    ``google-genai``-dependent) Gemini runner module for every caller of
-    this module, even ones that never touch the ``gemini`` platform.
+    imports lazily: avoids a needless import of the Gemini runner module
+    for every caller of this module, even ones that never touch the
+    ``gemini`` platform.
     """
     from argus.config import get_settings
     from argus.gemini_runner import run_session_gemini

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/argus/bench_default.toml

@@ -2,9 +2,11 @@
 #
 # See argus/bench.py's module docstring for the full override chain and
 # the bulk_reviewer vs. roles.<name> distinction. This file is the base
-# of that chain -- every entry below resolves to platform="claude-sdk"
-# with the exact models the pipeline used before the bench existed, so
-# shipping this file is a behavior-preserving no-op for a default install.
+# of that chain: [bulk_reviewer] defaults to platform="gemini"
+# (model="gemini-mini", caching="auto") for cost reasons across
+# generalist, specialist, and tests-and-docs reviewers, while individual
+# roles ([roles.cross-cutting], [roles.blocking-validator], and
+# [roles.feedback-verifier]) remain on platform="claude-sdk".
 #
 # To customize: create ./.argus/bench.toml or ~/.config/argus/bench.toml
 # with ONLY the keys you want to change (sparse overlay -- you never need
@@ -22,8 +24,8 @@
 # Applies as one unit to run_system_reviewer (per system group, including
 # gap-fill reviewers), every named specialist, and the tests-and-docs
 # reviewer. Each of those still resolves its own existing prompt file.
-platform = "claude-sdk"
-model    = "claude-default"
+platform = "gemini"
+model    = "gemini-mini"
 caching  = "auto"
 
 # The three [roles.*] tables below configure independent roles:

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/argus/cli.py

@@ -47,8 +47,9 @@ Environment variables (HTTP-mode opt-in):
 
 No storage env vars are required: with neither ``ARGUS_DB_URL`` nor the
 HTTP-shim URLs set, round history and checkpoints default to local SQLite.
-Required secrets are only one of ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN,
-GITHUB_TOKEN_RO, and OPENAI_API_KEY. ANTHROPIC_AUTH_TOKEN is the standard
+Required secrets are one of ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN,
+GITHUB_TOKEN_RO, OPENAI_API_KEY, and (by default, since bulk reviewers default
+to Gemini) GOOGLE_API_KEY. ANTHROPIC_AUTH_TOKEN is the standard
 mechanism for routing through a corporate LLM gateway/proxy instead of a
 real Anthropic API key (sent as ``Authorization: Bearer`` rather than
 ``x-api-key``) — the same convention the Anthropic SDK and Claude Code
@@ -177,11 +178,13 @@ def _load_settings() -> "Settings":
 def _check_settings(settings: "Settings") -> None:
     """Validate that critical secrets were loaded, fail loudly otherwise.
 
-    Only the three API credentials are required: one of ``ANTHROPIC_API_KEY``
-    / ``ANTHROPIC_AUTH_TOKEN`` (Agent SDK + LangChain), ``GITHUB_TOKEN_RO``
-    (diff fetch + clone), and ``OPENAI_API_KEY`` (plan-extraction path). No
-    storage configuration is required — with neither ``ARGUS_DB_URL`` nor
-    the HTTP-shim URLs set, history and checkpoints default to local SQLite.
+    Always required:
+    - ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN) for Agent SDK + LangChain
+    - GITHUB_TOKEN_RO for diff fetch + clone
+    - OPENAI_API_KEY for plan-extraction path
+
+    Additionally, if any leaf reviewer in the effective resolved bench config
+    requires the Gemini platform, GOOGLE_API_KEY is required.
 
     Args:
         settings: Resolved settings object.
@@ -193,6 +196,27 @@ def _check_settings(settings: "Settings") -> None:
         missing.append("GITHUB_TOKEN_RO")
     if not settings.OPENAI_API_KEY:
         missing.append("OPENAI_API_KEY")
+
+    from argus import bench
+
+    bench.clear_cache()
+    try:
+        raw_bench = bench.load_bench(settings=settings)
+    except Exception as exc:
+        logger.error("Invalid bench configuration: %s", exc)
+        sys.exit(1)
+
+    platforms_needed: set[str] = set()
+    bulk = raw_bench.get("bulk_reviewer")
+    if isinstance(bulk, dict) and "platform" in bulk:
+        platforms_needed.add(bulk["platform"])
+    for role_cfg in raw_bench.get("roles", {}).values():
+        if isinstance(role_cfg, dict) and "platform" in role_cfg:
+            platforms_needed.add(role_cfg["platform"])
+
+    if "gemini" in platforms_needed and not settings.GOOGLE_API_KEY:
+        missing.append("GOOGLE_API_KEY")
+
     if missing:
         logger.error(
             "Missing required secrets: %s. Add them to your shell or .env file.",
@@ -330,9 +354,10 @@ def _add_review_args(parser: argparse.ArgumentParser) -> None:
         default=_MODEL_OVERRIDE_UNSET,
         help=(
             "Override the model used by the system reviewer, specialist "
-            "reviewers, the writer, and the lite-review path (default: "
-            "claude-sonnet-4-6, or ARGUS_SPECIALIST_MODEL if already set in "
-            "the environment). Same effect as setting ARGUS_SPECIALIST_MODEL. "
+            "reviewers, the writer, and the lite-review path (forcing "
+            "bulk reviewers to claude-sdk with the specified model; default "
+            "without this flag routes bulk reviewers to gemini-mini). "
+            "Same effect as setting ARGUS_SPECIALIST_MODEL. "
             "Pass an empty string to clear an already-set "
             "ARGUS_SPECIALIST_MODEL for this run."
         ),
@@ -572,7 +597,6 @@ def _run_review(parser: argparse.ArgumentParser, args: argparse.Namespace) -> No
     except Exception as exc:  # pydantic ValidationError for missing required vars
         logger.error("Failed to load settings: %s", exc)
         sys.exit(1)
-    _check_settings(settings)
 
     # Applied AFTER _load_settings(), not before: _load_settings() calls
     # load_dotenv_early(..., override=False), which repopulates any env var
@@ -587,6 +611,12 @@ def _run_review(parser: argparse.ArgumentParser, args: argparse.Namespace) -> No
     _apply_model_override_flag("ARGUS_SPECIALIST_MODEL", args.specialist_model)
     _apply_model_override_flag("ARGUS_FRONTIER_MODEL", args.frontier_model)
 
+    from argus.config import clear_cache as clear_config_cache, get_settings
+
+    clear_config_cache()
+    settings = get_settings()
+    _check_settings(settings)
+
     from argus.models import ReviewRequest
 
     request = ReviewRequest(

{argus_code_review-0.2.2 → argus_code_review-0.2.3}/argus/config.py

@@ -92,20 +92,15 @@ class Settings(BaseSettings):
             path (``argus.llm.models.CLAUDE_DEFAULT``, default
             ``claude-sonnet-4-6``). Set via ``--specialist-model``; read
             directly from ``os.environ`` by ``argus.llm.models`` at import
-            time (module-level constant resolution, not a per-request
-            Settings lookup), so this field is never actually read off a
-            ``Settings`` instance anywhere in the codebase -- unlike
-            ``ARGUS_NO_PROMPT_OVERRIDES`` above, which genuinely is
-            (``prompts_runtime.override_dirs`` reads
-            ``settings.ARGUS_NO_PROMPT_OVERRIDES``). It's declared here
-            purely for documentation/discoverability, same as any other
-            env var this class's docstring covers.
+            time and by ``argus.bench`` (where setting it forces bulk reviewers
+            to claude-sdk with claude-default). Also read off a ``Settings``
+            instance during bench resolution when dependency-injected.
         ARGUS_FRONTIER_MODEL: Override the model used by the planner,
             coverage check, and cross-cutting reviewer
             (``argus.llm.models.CLAUDE_FRONTIER`` / ``CLAUDE_OPUS``). Set via
-            ``--frontier-model``; same read pattern (and same
-            documentation-only Settings field) as ``ARGUS_SPECIALIST_MODEL``
-            above.
+            ``--frontier-model``; read directly from ``os.environ`` by
+            ``argus.llm.models`` at import time (module-level constant
+            resolution, not a per-request Settings lookup).
         LANGSMITH_API_KEY / LANGSMITH_PROJECT: Optional tracing.
         OPENAI_BASE_URL: Optional override for OpenAI API endpoint (e.g. for proxying).
             Note that OPENAI_API_KEY will be forwarded as a Bearer token to whatever
@@ -131,10 +126,9 @@ class Settings(BaseSettings):
             additional headroom across all three reviewer platforms.
         GOOGLE_API_KEY: Gemini platform credential, consumed via the
             ``google_credential`` property by ``argus.gemini_runner``
-            (Track 3) whenever a role's bench entry resolves to
-            ``platform = "gemini"``. Only required if you actually
-            opt a role into that platform (see ``argus.bench``'s
-            override chain) -- the packaged default bench never does.
+            whenever a role's bench entry resolves to
+            ``platform = "gemini"``. Required for default review runs
+            since ``[bulk_reviewer]`` defaults to Gemini.
         GOOGLE_BASE_URL: Optional override for the Gemini API endpoint (e.g. for
             proxying). Mirrors ``OPENAI_BASE_URL`` above. Note that GOOGLE_API_KEY
             will be forwarded to whatever endpoint is configured here; point only