argus-code-review 0.3.3__tar.gz → 0.4.0__tar.gz

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-28
+
+### Changed
+
+- Gemini `caching = "auto"` (the packaged default for the bulk reviewers) no longer creates an explicit context cache; only `"on"` does. Explicit caching held just the system prompt and tools (about 1-3k tokens) and Gemini then reported only that slice as cached on every turn, while the growing conversation (the bulk of each request) was billed uncached. With no explicit cache, Gemini's automatic prefix caching applies to the whole repeated prefix. In paired live runs of the same PR the reported cached share of prompt tokens went from about 7% to about 90% (total prompt tokens about equal, verdicts and finding counts equivalent), and Argus's own cost estimate for the review fell from $12.66 to $3.20. That estimate is computed from the reported `cached_content_token_count`, not from a billing export, and Google does not document how automatic cache hits interact with `cached_content`, so treat the savings as unconfirmed. Because the default behavior of `auto` changes, this ships as a minor release (0.4.0). `caching = "on"` keeps the previous explicit-cache behavior.
+
+## [0.3.4] - 2026-10-23
+
+### Fixed
+
+- Gemini requests now retry HTTP 500/502/503/504 in place at every turn (up to three attempts with exponential jitter), retaining the conversation and without replaying tools. The outer session timeout still bounds the total work. The quota-aware whole-session turn-0 retry remains for 429s and transport errors, but a 5xx the SDK has already retried (three attempts) is not restarted, so a persistent 5xx costs at most three requests per turn; 429s are excluded from the SDK's status-only retry policy so daily-quota errors still fail fast.
+- Failed Gemini sessions preserve cost and tool accounting from completed turns, and include the failed turn index in their short failure detail.
+- Reviewer failure details now reach degraded-coverage reports instead of disappearing after the runner. Only canonical provider codes/statuses, standard HTTP reason phrases (such as `502 Bad Gateway`) and httpx transport error names are rendered; raw provider messages are never included. The cause precedes the reviewer-area name so it remains visible to consumers that truncate descriptions to 200 characters. Existing failure-reason values and database constraints are unchanged.
+- The model-registry check in the cross-cutting and lite prompts now applies to the repository under review instead of naming one specific package's constants. A package that has no registry of its own is no longer told it must use someone else's, and a legitimately overridden model value is not flagged. The em-dash character rule, which was one project's prose convention rather than a general review criterion, is removed from the shared prompt.
+
 ## [0.3.3] - 2026-10-22
 
 ### Changed
@@ -448,7 +463,9 @@ 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.3.3...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/redesignhealth/argus-review/compare/v0.3.4...v0.4.0
+[0.3.4]: https://github.com/redesignhealth/argus-review/compare/v0.3.3...v0.3.4
 [0.3.3]: https://github.com/redesignhealth/argus-review/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/redesignhealth/argus-review/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/redesignhealth/argus-review/compare/v0.3.0...v0.3.1

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.3.3
+Version: 0.4.0
 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

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/gemini_runner.py

@@ -54,7 +54,7 @@ key so that function's own ``group_name`` fallback still applies
 (this runner has no access to the caller's ``group.name`` -- only to
 ``entry.role``, which is a different, bench-level identifier).
 
-Explicit context caching (``entry.caching in {"auto", "on"}``) is
+Explicit context caching (``entry.caching == "on"``) is
 strictly best-effort: Gemini's explicit-cache API has a minimum
 content-size requirement a short prompt plus this small a toolset might
 not clear, so any exception raised while creating/reusing a cache is
@@ -147,7 +147,7 @@ import logging
 import os
 import random
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Any
 
@@ -177,14 +177,22 @@ logger = logging.getLogger(__name__)
 
 _MAX_TURNS_GEMINI = 100  # raised from 45 -- see TECH-6558
 
-# Both "auto" and "on" attempt explicit caching today -- there is no
-# separate heuristic distinguishing them yet (Track 1 defined the
-# `caching` values without one; see argus.bench's `_VALID_CACHING`). The
-# graceful-degradation try/except in `_maybe_activate_cache` is what
-# actually protects a caller who set "auto" against a too-small
-# prompt+toolset that can't clear Gemini's minimum cache-content-size
-# requirement. "off" skips caching entirely.
-_CACHE_ENABLED_VALUES = frozenset({"auto", "on"})
+# Only "on" creates an explicit cache. "auto" (the packaged default) and "off"
+# both send the whole request inline and leave caching to Gemini's own
+# automatic prefix caching, which is enabled by default on current models.
+#
+# Why "auto" is not explicit: an explicit cache holds only what is placed in
+# it at creation time (here the system prompt, tools and tool config, about
+# 1-3k tokens), and a request that references it ("cached_content=") must
+# not also carry those three fields. Every turn's growing conversation
+# (the diff plus all prior tool results) is then sent as ordinary
+# `contents`. In live A/B runs of the same PR,
+# explicit caching reported ~7% cached prompt tokens (exactly the cache size
+# on every turn) while caching="off" reported ~90%, with the same total
+# prompt volume. The graceful-degradation try/except in
+# `_maybe_activate_cache` still protects a caller who sets "on" against a
+# prompt+toolset that cannot clear Gemini's minimum cache size.
+_CACHE_ENABLED_VALUES = frozenset({"on"})
 
 _DEFAULT_READ_LIMIT = 2000  # mirrors argus.review_tools._DEFAULT_READ_LIMIT
 
@@ -219,7 +227,9 @@ _HTTP_TIMEOUT_FRACTION = 0.8
 # DEADLINE_EXCEEDED/INTERNAL, or an httpx timeout/connect/read/remote-protocol
 # error) before the model returned ANY response (i.e. on turn 0), so the retry
 # restarts the session cleanly from the beginning. Later failures are not
-# retried. The cooldown depends on the error kind (see `_retry_decision`):
+# restarted; the SDK retries only individual 5xx requests (see
+# `_HTTP_RETRY_ATTEMPTS`), and a 5xx it already retried is not restarted again,
+# so the restart covers 429 and transport errors only. The cooldown depends on the error kind (see `_retry_decision`):
 # 45-60 s jitter for 429/RESOURCE_EXHAUSTED (per-minute quota windows), 5-10 s
 # for 5xx/network errors; a server Retry-After/retryDelay >= 5 s is honored;
 # never more than 60 s. Daily-quota 429s are not retried. Overridable via
@@ -249,6 +259,14 @@ _TRANSIENT_HTTPX = (
     httpx.ReadError,
     httpx.RemoteProtocolError,
 )
+
+# SDK-level per-request retry of 5xx at any turn; the request is re-sent
+# unchanged, so no tools are replayed. 429s stay in _retry_decision because the
+# SDK cannot tell daily quota from per-minute limits or honor Retry-After.
+_HTTP_RETRY_ATTEMPTS = 3  # including the initial call
+_HTTP_RETRY_STATUS_CODES = (500, 502, 503, 504)
+_HTTP_RETRY_INITIAL_DELAY_S = 2.0
+_HTTP_RETRY_MAX_DELAY_S = 20.0
 _DETAIL_MAX_CHARS = 300
 _SECRET_RE = re.compile(
     r"(AIza[0-9A-Za-z_\-]{20,}|(?i:(?:api[_-]?key|key|token)=)[^&\s\"']+|"
@@ -271,8 +289,38 @@ class _Progress:
     """Mutable per-session state shared between attempts and the failure handler."""
 
     responses: int = 0  # successful generate_content responses received
+    last_turn: int | None = None  # 0-based index of the turn that last ran
     retried: bool = False
     retry_wait_s: float = 0.0
+    # Usage accrued so far, so a session that dies mid-flight still reports it.
+    prompt_tokens: int = 0
+    cached_tokens: int = 0
+    candidates_tokens: int = 0
+    thoughts_tokens: int = 0
+    tool_use_prompt_tokens: int = 0
+    tool_calls: list[str] = field(default_factory=list)
+
+    @property
+    def input_tokens(self) -> int:
+        # Gemini's prompt_token_count already includes the cached portion, so
+        # subtract it to avoid billing it at both input and cache-read rates.
+        # Tool-result tokens are billed as input.
+        return max(self.prompt_tokens - self.cached_tokens, 0) + self.tool_use_prompt_tokens
+
+    @property
+    def output_tokens(self) -> int:
+        # Thinking tokens are a separate additive bucket billed as output.
+        return self.candidates_tokens + self.thoughts_tokens
+
+    def cost_usd(self, model: str) -> float:
+        if self.responses == 0:
+            return 0.0
+        return estimate_cost_usd(
+            model=model,
+            input_tokens=self.input_tokens,
+            output_tokens=self.output_tokens,
+            cached_input_tokens=self.cached_tokens,
+        )
 
 
 def _scrub(text: str) -> str:
@@ -346,6 +394,8 @@ def _retry_decision(exc: BaseException) -> tuple[str, float] | None:
     if not _is_transient_error(exc):
         return None
     code, status = _error_code_status(exc)
+    if isinstance(exc, genai_errors.ServerError) and code in _HTTP_RETRY_STATUS_CODES:
+        return None  # the SDK already retried this request; a restart would repeat it
     server_delay = _retry_after_seconds(exc)
     if code == 429 or (status or "").upper() == "RESOURCE_EXHAUSTED":
         if _is_daily_quota(exc, server_delay):
@@ -767,7 +817,7 @@ async def _run_turns(
     repo_root: str,
     timeout_s: float,
     started_at: datetime,
-    progress: _Progress | None = None,
+    progress: _Progress,
 ) -> SessionResult:
     """The actual tool-calling loop. Returns ``failure_reason="turn_budget_exhausted"``
     when the loop ran out of turns without a ``finish_review`` call, else
@@ -834,6 +884,16 @@ async def _run_turns(
             label=label,
         )
 
+        # Retry only model calls, not detached synchronous cache creation.
+        request_http_options = types.HttpOptions(
+            retry_options=types.HttpRetryOptions(
+                attempts=_HTTP_RETRY_ATTEMPTS,
+                initial_delay=_HTTP_RETRY_INITIAL_DELAY_S,
+                max_delay=_HTTP_RETRY_MAX_DELAY_S,
+                http_status_codes=list(_HTTP_RETRY_STATUS_CODES),
+            )
+        )
+
         def _build_config(cache_name: str | None) -> types.GenerateContentConfig:
             # Gemini constraint (confirmed against the live API, not just
             # documentation): a request using `cached_content=` must NOT
@@ -847,11 +907,14 @@ async def _run_turns(
             # `CreateCachedContentConfig.tool_config`), so the cached
             # branch here sends `cached_content` alone.
             if cache_name:
-                return types.GenerateContentConfig(cached_content=cache_name)
+                return types.GenerateContentConfig(
+                    cached_content=cache_name, http_options=request_http_options
+                )
             return types.GenerateContentConfig(
                 system_instruction=system_prompt,
                 tools=gemini_tools,
                 tool_config=_FORCE_TOOL_CONFIG,
+                http_options=request_http_options,
             )
 
         config = _build_config(cached_content_name)
@@ -860,19 +923,14 @@ async def _run_turns(
             types.Content(role="user", parts=[types.Part.from_text(text=user_message)])
         ]
 
-        tool_calls: list[str] = []
         files_explored: list[str] = []
         exhausted = False
-        usage_prompt_total = 0
-        usage_candidates_total = 0
-        usage_cached_total = 0
-        usage_thoughts_total = 0
-        usage_tool_use_prompt_total = 0
 
         _mid_budget_nudge_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS_GEMINI)
 
         with review_tools.review_session(repo_root) as findings_sink:
             for _turn in range(_MAX_TURNS_GEMINI):
+                progress.last_turn = _turn
                 if (
                     _turn == _MAX_TURNS_GEMINI - _NUDGE_TURNS_BEFORE_BUDGET
                     and contents[-1].parts is not None
@@ -928,23 +986,16 @@ async def _run_turns(
                         model=model, contents=contents, config=config
                     )
 
-                if progress is not None:
-                    progress.responses += 1
+                progress.responses += 1
                 usage = response.usage_metadata
                 if usage is not None:
-                    usage_prompt_total += usage.prompt_token_count or 0
-                    usage_candidates_total += usage.candidates_token_count or 0
-                    usage_cached_total += usage.cached_content_token_count or 0
-                    # thoughts_token_count (thinking-mode output) and
-                    # tool_use_prompt_token_count (tool-result tokens fed
-                    # back to the model) are both billable and both
-                    # separate additive buckets, per
-                    # GenerateContentResponseUsageMetadata's own docstring
-                    # (total_token_count = prompt + candidates +
-                    # tool_use_prompt + thoughts) -- NOT already folded
-                    # into prompt_token_count/candidates_token_count.
-                    usage_thoughts_total += usage.thoughts_token_count or 0
-                    usage_tool_use_prompt_total += usage.tool_use_prompt_token_count or 0
+                    # thoughts and tool-use prompt tokens are billable, separate
+                    # additive buckets (not folded into prompt/candidates counts).
+                    progress.prompt_tokens += usage.prompt_token_count or 0
+                    progress.candidates_tokens += usage.candidates_token_count or 0
+                    progress.cached_tokens += usage.cached_content_token_count or 0
+                    progress.thoughts_tokens += usage.thoughts_token_count or 0
+                    progress.tool_use_prompt_tokens += usage.tool_use_prompt_token_count or 0
 
                 function_calls = response.function_calls or []
                 if not function_calls:
@@ -998,7 +1049,7 @@ async def _run_turns(
                 for call in function_calls:
                     name = call.name or ""
                     args = dict(call.args or {})
-                    tool_calls.append(name)
+                    progress.tool_calls.append(name)
                     output, is_error = await asyncio.to_thread(_execute_tool_call, name, args)
                     if is_error and name != "finish_review":
                         logger.warning("Tool call failed [%s]: %s", name, output[:200])
@@ -1030,35 +1081,19 @@ async def _run_turns(
             result_text = _build_result_text(findings_sink, files_explored)
 
         finished_at = datetime.now(timezone.utc)
-        unique_tool_names = sorted(set(tool_calls))
-
-        # Gemini's prompt_token_count already INCLUDES the cached portion
-        # (unlike Anthropic's fully-separate input/cache-read counters,
-        # which is the convention estimate_cost_usd's cached_input_tokens
-        # documents) -- so the cached amount must be subtracted out of the
-        # uncached input count here, or it would be billed at both the full
-        # input rate AND the cache-read rate. tool_use_prompt tokens are
-        # billed at the input rate (added in); thoughts tokens are billed
-        # at the output rate (added in) -- see the accumulation loop above.
-        input_tokens = max(usage_prompt_total - usage_cached_total, 0) + usage_tool_use_prompt_total
-        output_tokens = usage_candidates_total + usage_thoughts_total
-        cost_usd = estimate_cost_usd(
-            model=model,
-            input_tokens=input_tokens,
-            output_tokens=output_tokens,
-            cached_input_tokens=usage_cached_total,
-        )
+        unique_tool_names = sorted(set(progress.tool_calls))
+        cost_usd = progress.cost_usd(model)
 
-        tools_str = f" (tools: {', '.join(unique_tool_names)})" if tool_calls else ""
+        tools_str = f" (tools: {', '.join(unique_tool_names)})" if progress.tool_calls else ""
         logger.info(
             "Gemini agent done [%s]: %d tool calls%s, cost=$%.4f input_tokens=%d cached_tokens=%d output_tokens=%d",
             label or "unlabeled",
-            len(tool_calls),
+            len(progress.tool_calls),
             tools_str,
             cost_usd,
-            input_tokens,
-            usage_cached_total,
-            output_tokens,
+            progress.input_tokens,
+            progress.cached_tokens,
+            progress.output_tokens,
         )
 
         return SessionResult(
@@ -1067,7 +1102,7 @@ async def _run_turns(
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=len(tool_calls),
+            tool_call_count=len(progress.tool_calls),
             tool_names=unique_tool_names,
             # No Context7 MCP integration in scope for this runner (see module
             # docstring) -- always 0, never derived from tool_calls.
@@ -1207,19 +1242,21 @@ async def run_session_gemini(
     except (TimeoutError, httpx.TimeoutException) as exc:
         finished_at = datetime.now(timezone.utc)
         logger.warning(
-            "Gemini session [%s] timed out after %ss (%s)",
+            "Gemini session [%s] timed out after %ss (%s), %d turn(s) and %d tool call(s) done",
             label or "unlabeled",
             effective_timeout_s,
             type(exc).__name__,
+            progress.responses,
+            len(progress.tool_calls),
         )
         return SessionResult(
             result_text="",
-            cost_usd=0.0,
+            cost_usd=progress.cost_usd(model),
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=0,
-            tool_names=[],
+            tool_call_count=len(progress.tool_calls),
+            tool_names=sorted(set(progress.tool_calls)),
             context7_call_count=0,
             model=model,
             failure_reason="timeout",
@@ -1259,6 +1296,8 @@ async def run_session_gemini(
         # subprocess "worker" the way the Claude Agent SDK path does.
         finished_at = datetime.now(timezone.utc)
         detail = _failure_detail(exc)
+        if progress.last_turn is not None:
+            detail = f"{detail}, turn {progress.last_turn}"
         logger.warning(
             "Gemini session [%s] failed after %.1fs (%s, %s%s): %s",
             label or "unlabeled",
@@ -1270,12 +1309,12 @@ async def run_session_gemini(
         )
         return SessionResult(
             result_text="",
-            cost_usd=0.0,
+            cost_usd=progress.cost_usd(model),
             duration_seconds=(finished_at - started_at).total_seconds(),
             started_at=started_at,
             finished_at=finished_at,
-            tool_call_count=0,
-            tool_names=[],
+            tool_call_count=len(progress.tool_calls),
+            tool_names=sorted(set(progress.tool_calls)),
             context7_call_count=0,
             model=model,
             failure_reason="worker_crashed",

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/helpers.py

@@ -11,6 +11,8 @@ import re
 from pathlib import Path
 from typing import Any
 
+import httpx
+
 from argus.models import Finding, ReviewResponse, RiskLevel, Severity, Verdict
 from argus.pipeline_models import RawFinding, SystemReviewResult
 
@@ -145,6 +147,31 @@ def collect_reviewed_files(results: list[SystemReviewResult]) -> set[str]:
     return reviewed
 
 
+def _concrete_subclass_names(base: type[BaseException]) -> set[str]:
+    names = {base.__name__}
+    for sub in base.__subclasses__():
+        names |= _concrete_subclass_names(sub)
+    return names
+
+
+# Only canonical provider codes/statuses, HTTP reason phrases and transport
+# exception names may be rendered into reports, never arbitrary exception text
+# or payloads. Transport names come from httpx itself so they cannot drift.
+_TRANSPORT_ERROR_NAMES = sorted(
+    _concrete_subclass_names(httpx.TransportError) | {"HTTPStatusError"}
+)
+_CANONICAL_FAILURE_DETAIL_RE = re.compile(
+    r"(?:[1-5][0-9]{2}(?: (?:INTERNAL|UNAVAILABLE|RESOURCE_EXHAUSTED|"
+    r"DEADLINE_EXCEEDED|UNAUTHENTICATED|PERMISSION_DENIED|INVALID_ARGUMENT|"
+    r"NOT_FOUND|FAILED_PRECONDITION|UNKNOWN|CANCELLED|ABORTED|OUT_OF_RANGE|"
+    r"UNIMPLEMENTED|DATA_LOSS|"
+    # HTTP reason phrase (non-JSON error body), e.g. "Bad Gateway"; <= 40 chars.
+    r"(?=[A-Za-z ]{1,40}(?![A-Za-z ]))[A-Z][a-z]+(?: [A-Z][a-z]+)*))?|"
+    r"(?:" + "|".join(_TRANSPORT_ERROR_NAMES) + r"|ServerError|ClientError|APIError))"
+    r"(?: \(daily quota\))?(?:, turn [0-9]+)?"
+)
+
+
 def failed_reviewer_labels(results: list[SystemReviewResult]) -> list[tuple[str, str]]:
     """Return ``(system_group, failure_reason)`` pairs for reviewers that did
     not complete normally, in the order they appear in ``results``.
@@ -159,10 +186,13 @@ def failed_reviewer_labels(results: list[SystemReviewResult]) -> list[tuple[str,
     """
     labels: list[tuple[str, str]] = []
     for result in results:
-        reason = result.failure_reason
+        reason: str | None = result.failure_reason
         if reason is None and result.timed_out:
             reason = "timeout"
         if reason is not None:
+            detail = result.failure_detail
+            if detail and _CANONICAL_FAILURE_DETAIL_RE.fullmatch(detail):
+                reason = f"{reason}: {detail}"
             labels.append((result.system_group, reason))
     return labels
 
@@ -272,15 +302,16 @@ def build_degraded_coverage_findings(
     """
     findings: list[Finding] = []
     for label, reason in failed_labels:
+        reason_code, _, detail = reason.partition(": ")
         is_precheck = label.startswith("precheck:")
         subject = "Precheck scanner" if is_precheck else "Reviewer session"
-        is_missing = reason == _SCANNER_NOT_INSTALLED_REASON
+        is_missing = reason_code == _SCANNER_NOT_INSTALLED_REASON
         # Distinct wording from a crash/timeout: the reviewer was alive and
         # exploring, it just never reached finish_review.
-        is_exhausted = reason == "turn_budget_exhausted"
+        is_exhausted = reason_code == "turn_budget_exhausted"
         if is_missing:
             reason_desc = "is not installed"
-        elif reason == "timeout":
+        elif reason_code == "timeout":
             reason_desc = "timed out"
         elif is_exhausted:
             reason_desc = "ran out of turns before finishing"
@@ -302,16 +333,22 @@ def build_degraded_coverage_findings(
                 f"Re-run the review or manually inspect the changes in '{label}' "
                 f"to ensure potential issues were not missed due to {reason}."
             )
+        if detail:
+            # Cause first: API/MCP summaries may clip at 200 chars, and the
+            # area name is unbounded model output.
+            description = f"{subject} {reason_desc}. Area: '{label}'. Coverage is degraded."
+        else:
+            description = (
+                f"{subject} '{label}' {reason_desc} and produced no findings. "
+                "Coverage for this area is degraded."
+            )
         findings.append(
             Finding(
                 severity=Severity.SUGGESTION,
                 category="coverage-gap",
                 file=None,
                 line=None,
-                description=(
-                    f"{subject} '{label}' {reason_desc} and produced no findings. "
-                    "Coverage for this area is degraded."
-                ),
+                description=description,
                 suggestion=suggestion,
             )
         )

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/pipeline_models.py

@@ -168,6 +168,14 @@ class SystemReviewResult(BaseModel):
         default=False,
         description="True when failure_reason == 'timeout'; kept for back-compat.",
     )
+    failure_detail: str | None = Field(
+        default=None,
+        description=(
+            "Short, key-free cause for failure_reason (e.g. '503 UNAVAILABLE, turn 45'), "
+            "copied from the runner's SessionResult. Report/degraded-coverage text only -- "
+            "not persisted to agent_runs and never parsed for control flow."
+        ),
+    )
 
     @model_validator(mode="before")
     @classmethod

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/prompts/pr-review-cross-cutting.md

@@ -87,12 +87,11 @@ Principle: if an LLM/AI pipeline builds execution, retry, state-tracking, or par
 Architecture-mandate violations (an adopted design doc names a framework for a concern and the code uses a different approach for that same concern) are standing conformance debt, not a one-time "was this broken before the PR" question. **Causal-scope-filter override**: this overrides the causal scope-check test used elsewhere in this prompt -- if this diff modifies or extends a pipeline that is already non-compliant, the finding is still in scope. Only skip when the diff does not touch the non-compliant pipeline's code at all.
 
 ### Model Registry Compliance (BLOCKING)
-- All LLM model identifiers MUST come from `argus.llm.models`'s exported constants (`GPT_MINI`, `CLAUDE_FRONTIER`, `CLAUDE_OPUS`, `CLAUDE_DEFAULT`, `CLAUDE_MINI`), which resolve `ALIAS_MAP` entries — only register an alias that has an actual call site; this is a standalone, isolated package, not a monorepo, so there's no value in carrying unused registry entries.
-- Flag as **BLOCKING** any new hardcoded model strings the diff introduces — e.g., literal `"gpt-5.4-mini"`, `"claude-sonnet-5"`, `"claude-haiku-4-5"`, or deprecated names like `"gpt-4o"`, `"o3"`, `"claude-3-*"`. This targets model-SELECTION code (a call site choosing which model to use); it does not apply to a legacy pin like `"claude-sonnet-5"` appearing as a `--specialist-model`/`ARGUS_SPECIALIST_MODEL` CLI/env override value, or in docs/tests demonstrating that override -- such a value remains a legitimate override even after it stops being the hardcoded default.
-- Short-lived eval / preview pins are allowed only via `EXPERIMENTAL_MODELS` in `argus/llm/models.py` (with a comment naming a tracking issue/PR and expected removal date) or via inline `# model-registry: allow -- <reason>` comments on user-input alias keys (not provider model identifiers).
-
-### Character Hygiene (cross-file)
-- Confirm the lines ADDED by this diff contain no em-dash characters (U+2014). Flag every added line that contains one. Scope this to diff-added lines only (prose in pre-existing code or docs is out of scope).
+- Judge this against the repository under review, never against a fixed package name. If the repository has a central model registry (a module that exports model aliases or constants for call sites to import -- commonly something like `ALIAS_MAP`, `MODELS`, or an `llm/models.py`), all LLM model identifiers MUST come from it.
+- Flag as **BLOCKING** any new hardcoded model string the diff introduces in model-SELECTION code -- e.g. a literal `"gpt-5.4-mini"`, `"claude-sonnet-5"`, `"claude-haiku-4-5"`, or deprecated names like `"gpt-4o"`, `"o3"`, `"claude-3-*"`. This targets the call site choosing which model to use; it does not apply to a value passed through a CLI/env override (e.g. a `--*-model` flag) or shown in docs or tests demonstrating that override.
+- Only register an alias that has an actual call site; an unused registry entry is dead weight, not a defect worth blocking on.
+- Short-lived eval or preview pins belong in the registry's own experimental section (with a comment naming a tracking issue and an expected removal date) or behind an inline `# model-registry: allow -- <reason>` comment.
+- If the repository has no such registry, do not demand one. Report hardcoded provider model identifiers as a SUGGESTION only when the repository's own conventions clearly place configuration values outside code.
 
 ## Output
 

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/prompts/pr-review-lite.md

@@ -21,7 +21,7 @@ Review only the changed code for these issues:
 - Blocking I/O calls in async functions (e.g. `requests` instead of `httpx`)
 
 ### Model Registry
-- Hardcoded LLM model strings (e.g. `"claude-sonnet-5"`, `"gpt-5.4-mini"`) — must use constants from `argus.llm.models` (`CLAUDE_DEFAULT`, `CLAUDE_FRONTIER`, `CLAUDE_OPUS`, `CLAUDE_MINI`, `GPT_MINI`). This targets model-SELECTION code (a call site choosing which model to use); it does not apply to `claude-sonnet-5` appearing as a `--specialist-model`/`ARGUS_SPECIALIST_MODEL` CLI/env override value, or in docs/tests demonstrating that override -- `claude-sonnet-5` (the previous `CLAUDE_DEFAULT` pin) remains a valid override value even though it's no longer the hardcoded default.
+- Hardcoded LLM model strings in model-selection code (e.g. `"claude-sonnet-5"`, `"gpt-5.4-mini"`) — when the repository has a central registry of model aliases or constants, call sites must use it. A value passed through a CLI/env override (e.g. a `--*-model` flag), or shown in docs or tests demonstrating that override, is legitimate.
 
 ## Out of Scope
 Do NOT flag: security deep-dives, performance analysis, test coverage gaps, architectural concerns, code style preferences, or cross-file integration issues. Those require a full Argus review.

{argus_code_review-0.3.3 → argus_code_review-0.4.0}/argus/runners.py

@@ -734,6 +734,18 @@ _SPECIALIST_PROMPT_MAP: dict[SpecialistName, str] = {
 # ---------------------------------------------------------------------------
 
 
+def _apply_session_failure(result: SystemReviewResult, session: SessionResult) -> None:
+    """Copy a session's failure state onto its parsed reviewer result.
+
+    Goes through the sync helper because a bare attribute assignment would
+    bypass ``SystemReviewResult``'s construction-time ``mode="before"`` validator.
+    """
+    result.timed_out, result.failure_reason = _sync_timed_out_and_failure_reason(
+        session.timed_out, session.failure_reason
+    )
+    result.failure_detail = session.failure_detail
+
+
 def _build_agent_run(
     *,
     session: SessionResult,
@@ -856,15 +868,7 @@ async def run_system_reviewer(
     )
     result = _parse_review_result(session.result_text, group.name)
     result.cost_usd = session.cost_usd
-    # Set both fields via the shared sync helper (not a bare attribute
-    # assignment) so `result.timed_out` stays correctly synced even before
-    # this object is next reconstructed via model_validate() -- a plain
-    # `result.failure_reason = session.failure_reason` bypasses
-    # SystemReviewResult's `mode="before"` validator entirely, since that
-    # validator only fires at construction time.
-    result.timed_out, result.failure_reason = _sync_timed_out_and_failure_reason(
-        session.timed_out, session.failure_reason
-    )
+    _apply_session_failure(result, session)
     agent_run = _build_agent_run(
         session=session,
         agent_name=f"system:{group.name}",
@@ -954,15 +958,7 @@ async def run_specialist_reviewer(
     )
     result = _parse_review_result(session.result_text, f"{group.name}::{specialist}")
     result.cost_usd = session.cost_usd
-    # Set both fields via the shared sync helper (not a bare attribute
-    # assignment) so `result.timed_out` stays correctly synced even before
-    # this object is next reconstructed via model_validate() -- a plain
-    # `result.failure_reason = session.failure_reason` bypasses
-    # SystemReviewResult's `mode="before"` validator entirely, since that
-    # validator only fires at construction time.
-    result.timed_out, result.failure_reason = _sync_timed_out_and_failure_reason(
-        session.timed_out, session.failure_reason
-    )
+    _apply_session_failure(result, session)
     agent_run = _build_agent_run(
         session=session,
         agent_name=f"specialist:{group.name}::{specialist}",
@@ -1043,15 +1039,7 @@ async def run_cross_cutting_reviewer(
     )
     result = _parse_review_result(session.result_text, "cross-cutting")
     result.cost_usd = session.cost_usd
-    # Set both fields via the shared sync helper (not a bare attribute
-    # assignment) so `result.timed_out` stays correctly synced even before
-    # this object is next reconstructed via model_validate() -- a plain
-    # `result.failure_reason = session.failure_reason` bypasses
-    # SystemReviewResult's `mode="before"` validator entirely, since that
-    # validator only fires at construction time.
-    result.timed_out, result.failure_reason = _sync_timed_out_and_failure_reason(
-        session.timed_out, session.failure_reason
-    )
+    _apply_session_failure(result, session)
     agent_run = _build_agent_run(
         session=session,
         agent_name="cross-cutting",
@@ -1113,15 +1101,7 @@ async def run_tests_and_docs_reviewer(
     )
     result = _parse_review_result(session.result_text, "tests-and-docs")
     result.cost_usd = session.cost_usd
-    # Set both fields via the shared sync helper (not a bare attribute
-    # assignment) so `result.timed_out` stays correctly synced even before
-    # this object is next reconstructed via model_validate() -- a plain
-    # `result.failure_reason = session.failure_reason` bypasses
-    # SystemReviewResult's `mode="before"` validator entirely, since that
-    # validator only fires at construction time.
-    result.timed_out, result.failure_reason = _sync_timed_out_and_failure_reason(
-        session.timed_out, session.failure_reason
-    )
+    _apply_session_failure(result, session)
     agent_run = _build_agent_run(
         session=session,
         agent_name="tests-and-docs",