argus-code-review 0.2.7__tar.gz → 0.2.8__tar.gz

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.8] - 2026-10-02
+
+### Changed
+
+- Raised the Claude-path turn budget from 30 to 50 and the default reviewer session
+  timeout from 900 to 1500 seconds globally across all runner platforms through
+  `ARGUS_SESSION_TIMEOUT` (TECH-7093), preserving headroom for longer sessions.
+- Added Claude's budget disclosure and supported `PostToolUse`/`PostToolUseFailure`
+  hook-based convergence warnings (derived from budget constants; 37 and 47 tool calls
+  by default), using truthful top-level tool-call counts, including failed calls.
+- Decoupled the Claude and OpenAI turn-budget constants; OpenAI remains at 30 turns.
+
 ## [0.2.7] - 2026-09-26
 
 ### Fixed
@@ -356,7 +368,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.7...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.8...HEAD
+[0.2.8]: https://github.com/redesignhealth/argus-review/compare/v0.2.7...v0.2.8
 [0.2.7]: https://github.com/redesignhealth/argus-review/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/redesignhealth/argus-review/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/redesignhealth/argus-review/compare/v0.2.4...v0.2.5

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.2.7
+Version: 0.2.8
 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.2.7 → argus_code_review-0.2.8}/argus/config.py

@@ -2,7 +2,7 @@
 
 A slim ``pydantic-settings`` implementation. All configuration comes from
 environment variables (or a local ``.env`` file loaded via
-``argus.dotenv_utils``) — no AWS, no SSM.
+``argus.dotenv_utils``) -- no AWS, no SSM.
 """
 
 from __future__ import annotations
@@ -15,7 +15,7 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 # ``argus.runners._SUBPROCESS_TIMEOUT_S`` (the fallback used when no Settings
 # instance is available, mostly tests) imports this same constant rather than
 # hardcoding its own copy, so the two can never drift out of sync.
-DEFAULT_ARGUS_SESSION_TIMEOUT_S = 900
+DEFAULT_ARGUS_SESSION_TIMEOUT_S = 1500
 
 
 class Settings(BaseSettings):
@@ -62,7 +62,7 @@ class Settings(BaseSettings):
             ``argus.precheck``.
         ARGUS_STOCK_SEMGREP_PACKS: Comma-separated semgrep registry pack IDs
             (e.g. ``"p/secrets"``) to run alongside (or instead of) a custom
-            ``ARGUS_RULES_DIR`` — unlike a local rules directory, each pack
+            ``ARGUS_RULES_DIR`` -- unlike a local rules directory, each pack
             is fetched over the network by semgrep itself on first use
             (cached locally after). Unset by default: this is an opt-in
             addition of vetted, community-maintained rules, not a silent
@@ -74,8 +74,8 @@ class Settings(BaseSettings):
             (``PrecheckResult.failed_scanners``/``missing_scanners``
             non-empty) instead of the default fail-open
             behavior (surface it in the review comment's degraded-coverage
-            section — see ``argus.helpers.build_degraded_coverage_labels``
-            — but let the review's own verdict stand on its own merits).
+            section -- see ``argus.helpers.build_degraded_coverage_labels``
+            -- but let the review's own verdict stand on its own merits).
             False by default: every other part of this module's design is
             deliberately fail-open (a broken scanner should never be the
             reason a review can't complete), and this flag exists for
@@ -117,14 +117,21 @@ class Settings(BaseSettings):
             Context7 call.
         ARGUS_SESSION_TIMEOUT: Wall-clock seconds a reviewer subprocess is
             allowed to run before it is killed and reported as a failure.
-            Defaults to 900 (15 minutes) — first raised from 300 to 420 after
+            Defaults to 1500 (25 minutes) -- first raised from 300 to 420 after
             production logs showed legitimate (non-runaway) specialist
             reviewers finishing as late as 294s, right at the old timeout's
             edge; raised again to 600 to match rh-data-platform's
             production-proven value ahead of this package taking over as the
             actual production reviewer (rh-data-platform's review_service is
-            being retired in its favor); raised once more to 900 for
-            additional headroom across all three reviewer platforms.
+            being retired in its favor); raised to 900 for additional headroom
+            across all three reviewer platforms; raised to 1500 in TECH-7093.
+            This timeout is deliberately global to all runner platforms through
+            ARGUS_SESSION_TIMEOUT, rather than scoped only to Claude, to preserve
+            a single operator control across runners. In production, an observed
+            cross-cutting session ran 533.8s under the 30-turn cap; linear
+            scaling 30 to 50 projects ~890s, meaning 900s leaves virtually zero
+            headroom. 1500s preserves roughly 1.69x margin, critical because a
+            timeout kill discards all reviewer output.
         GOOGLE_API_KEY: Gemini platform credential, consumed via the
             ``google_credential`` property by ``argus.gemini_runner``
             whenever a role's bench entry resolves to
@@ -206,7 +213,7 @@ class Settings(BaseSettings):
 
         Callers that need to hand this credential to something that itself
         reads an env var (the spawned ``claude`` CLI subprocess) must set
-        the SAME variable name the caller configured — forcing everything
+        the SAME variable name the caller configured -- forcing everything
         to ``ANTHROPIC_API_KEY`` would send a proxy/gateway bearer token as
         an ``x-api-key``, which not every gateway accepts. ``ANTHROPIC_API_KEY``
         wins when both are set, matching the Anthropic SDK's own precedence.

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/argus/gemini_runner.py

@@ -41,8 +41,9 @@ function call the model requests each turn (there can be more than
 one), feeding all of their results back as a single follow-up turn --
 until the model stops requesting function calls, calls
 ``finish_review``, or the turn budget (``_MAX_TURNS_GEMINI``, this
-module's own budget, independent of the Claude/OpenAI paths' shared
-``argus.runners._MAX_TURNS``) is exhausted. Findings arrive via
+module's own budget, independent of the Claude path's
+``argus.runners._MAX_TURNS_CLAUDE`` and the OpenAI path's
+``argus.openai_runner._MAX_TURNS_OPENAI``) is exhausted. Findings arrive via
 ``report_finding`` tool calls into ``review_tools``' per-session sink,
 not as a JSON blob embedded in the model's own text -- so, to keep this
 task's blast radius contained to this file plus ``argus.bench``'s

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/argus/openai_runner.py

@@ -40,7 +40,7 @@ the model requests each turn (there can be more than one), chaining the
 conversation state forward via ``previous_response_id`` and feeding back
 all tool outputs as ``function_call_output`` items -- until the model stops
 requesting function calls, calls ``finish_review``, or the turn budget
-(``argus.runners._MAX_TURNS``) is exhausted. Findings arrive via
+(``_MAX_TURNS_OPENAI``) is exhausted. Findings arrive via
 ``report_finding`` tool calls into ``review_tools``' per-session sink,
 not as a JSON blob embedded in the model's own text -- so, to keep this
 task's blast radius contained, the final ``SessionResult.result_text`` is
@@ -110,7 +110,6 @@ from argus.bench import BenchEntry
 from argus.llm.models import estimate_cost_usd
 from argus.llm.models import resolve as resolve_model_alias
 from argus.runners import (
-    _MAX_TURNS,
     _MID_BUDGET_NUDGE,
     _NUDGE_TURNS_BEFORE_BUDGET,
     _SUBPROCESS_TIMEOUT_S,
@@ -123,6 +122,8 @@ from argus.runners import (
 
 logger = logging.getLogger(__name__)
 
+_MAX_TURNS_OPENAI = 30
+
 _DEFAULT_READ_LIMIT = 2000  # mirrors argus.review_tools._DEFAULT_READ_LIMIT
 
 # Matches the fenced-json extraction argus.helpers.parse_review_result
@@ -417,7 +418,7 @@ async def _run_turns(
     whatever those completed turns actually produced and billed.
     """
     system_prompt = (
-        system_prompt + "\n\n" + _TURN_BUDGET_SYSTEM_PROMPT_LINE.format(max_turns=_MAX_TURNS)
+        system_prompt + "\n\n" + _TURN_BUDGET_SYSTEM_PROMPT_LINE.format(max_turns=_MAX_TURNS_OPENAI)
     )
     api_key = getattr(settings, "OPENAI_API_KEY", None)
     base_url = getattr(settings, "OPENAI_BASE_URL", None)
@@ -504,13 +505,13 @@ async def _run_turns(
         )
 
     exhausted = False
-    _mid_budget_nudge_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS)
+    _mid_budget_nudge_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS_OPENAI)
     try:
         async with asyncio.timeout(timeout_s):
             with review_tools.review_session(repo_root) as findings_sink:
                 previous_response_id: str | None = None
                 tool_outputs: list[dict[str, Any]] = []
-                for _turn in range(_MAX_TURNS):
+                for _turn in range(_MAX_TURNS_OPENAI):
                     create_kwargs: dict[str, Any] = {
                         "model": model,
                         "instructions": system_prompt,
@@ -625,7 +626,7 @@ async def _run_turns(
                     if finished:
                         break
 
-                    if _turn + 1 == _MAX_TURNS - _NUDGE_TURNS_BEFORE_BUDGET:
+                    if _turn + 1 == _MAX_TURNS_OPENAI - _NUDGE_TURNS_BEFORE_BUDGET:
                         tool_outputs.append({"role": "user", "content": _TURN_BUDGET_NUDGE})
 
                     # Not an `elif` -- these are two independent checkpoints
@@ -643,7 +644,7 @@ async def _run_turns(
                     logger.warning(
                         "OpenAI session [%s] exhausted its %d-turn budget without a finish_review call",
                         label or "unlabeled",
-                        _MAX_TURNS,
+                        _MAX_TURNS_OPENAI,
                     )
                     exhausted = True
 

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/argus/runners.py

@@ -30,6 +30,7 @@ from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
     ClaudeSDKClient,
+    HookMatcher,
     ResultMessage,
     TaskStartedMessage,
     TextBlock,
@@ -38,6 +39,13 @@ from claude_agent_sdk import (
     ToolUseBlock,
     UserMessage,
 )
+from claude_agent_sdk.types import (
+    HookContext,
+    HookEvent,
+    PostToolUseFailureHookSpecificOutput,
+    PostToolUseHookSpecificOutput,
+    SyncHookJSONOutput,
+)
 from langsmith import traceable
 from langsmith.run_helpers import LangSmithExtra, get_current_run_tree
 
@@ -141,9 +149,10 @@ if _CROSS_CUTTING_MODEL != ALIAS_MAP["claude-opus"]:
         _CROSS_CUTTING_MODEL,
     )
 
-# Shared by every Claude-path session (system/specialist/cross-cutting/tests-and-docs
-# reviewers, feedback verifier, blocking validator).
-_MAX_TURNS = 30
+# Turn budget for Claude-path sessions (system/specialist/cross-cutting/tests-and-docs
+# reviewers, feedback verifier, blocking validator) -- raised from 30 to 50
+# in TECH-7093.
+_MAX_TURNS_CLAUDE = 50
 
 # Nudges the Gemini/OpenAI turn loops (see their own _run_turns) to call
 # finish_review a few turns before the budget runs out.
@@ -155,8 +164,8 @@ _TURN_BUDGET_NUDGE = (
 )
 
 # One-sentence turn-budget disclosure appended to the Gemini/OpenAI reviewer
-# system prompts. Not used on the Claude path (_run_claude_session), which
-# has no mid-stream nudge for the sentence to work with.
+# system prompts. See _TURN_BUDGET_SYSTEM_PROMPT_LINE_CLAUDE below for the
+# Claude path equivalent.
 _TURN_BUDGET_SYSTEM_PROMPT_LINE = (
     "You have at most {max_turns} turns. Call `finish_review` before you run out -- "
     "a review that never calls it is discarded entirely."
@@ -187,7 +196,7 @@ def _compute_mid_budget_nudge_turn(max_turns: int) -> int | None:
     colliding the two nudges onto the same turn -- which would either
     double-post one message, or silently drop the mid-budget one. Not
     reachable at today's values (75 vs. 97 for Gemini's 100-turn budget, 22
-    vs. 27 for the shared 30-turn budget) -- only with a much smaller
+    vs. 27 for OpenAI's 30-turn budget) -- only with a much smaller
     ``max_turns``.
     """
     checkpoint_turn = int(max_turns * _MID_BUDGET_NUDGE_FRACTION)
@@ -197,6 +206,159 @@ def _compute_mid_budget_nudge_turn(max_turns: int) -> int | None:
     return checkpoint_turn
 
 
+# Claude-path equivalent of the disclosure line above. Claude-path reviewers do
+# not have a `finish_review` tool; they finish by emitting their role's final
+# JSON output block.
+_TURN_BUDGET_SYSTEM_PROMPT_LINE_CLAUDE = (
+    "You have at most {max_turns} turns. Emit your final JSON output block before you "
+    "run out -- a review that never emits it is discarded entirely."
+)
+
+
+# Tool-call budget warning thresholds and truthful messages for Claude-path
+# sessions.
+#
+# In claude-agent-sdk 0.1.81, supported tool-lifecycle hooks that can inject
+# feedback via hookSpecificOutput.additionalContext are PostToolUse and
+# PostToolUseFailure. PostToolBatch is the exact-per-turn future option in
+# Claude Code, but is untyped and unsupported in this SDK version.
+# We attach to PostToolUse and PostToolUseFailure to track combined tool
+# invocations and inject non-blocking convergence/stop nudges.
+#
+# Thresholds are derived from the turn budget constants: the final threshold
+# fires at the emergency checkpoint (_MAX_TURNS_CLAUDE - _NUDGE_TURNS_BEFORE_BUDGET,
+# or 47 under max_turns=50), and the mid threshold fires at the 75% checkpoint
+# (_compute_mid_budget_nudge_turn(_MAX_TURNS_CLAUDE), or 37 under max_turns=50).
+# Because every continuing agent turn has at least one tool call, these thresholds
+# are reachable no later than the corresponding tool-using turns under max_turns.
+# Multiple or parallel tool calls per turn can make the truthful tool-count advisory
+# fire earlier. The copy makes no turns-left claim, stating only the exact number of
+# tool calls made so far.
+def _compute_claude_tool_budget_thresholds(max_turns: int) -> tuple[int, int]:
+    """Compute and validate Claude tool-budget nudge thresholds (mid, final).
+
+    Returns:
+        tuple[int, int]: (mid_threshold, final_threshold) where mid_threshold
+        strictly precedes final_threshold.
+
+    Raises:
+        ValueError: If max_turns produces a mid-budget checkpoint that does not
+            strictly precede the final threshold (e.g. colliding or inverted thresholds
+            from a small budget).
+    """
+    final_threshold = max_turns - _NUDGE_TURNS_BEFORE_BUDGET
+    mid_threshold = _compute_mid_budget_nudge_turn(max_turns)
+    if mid_threshold is None:
+        raise ValueError(
+            f"Invalid max_turns={max_turns}: mid-budget checkpoint must precede "
+            f"the final budget nudge threshold ({final_threshold})"
+        )
+    return mid_threshold, final_threshold
+
+
+_TOOL_BUDGET_MID_THRESHOLD: int
+_TOOL_BUDGET_FINAL_THRESHOLD: int
+_TOOL_BUDGET_MID_THRESHOLD, _TOOL_BUDGET_FINAL_THRESHOLD = _compute_claude_tool_budget_thresholds(
+    _MAX_TURNS_CLAUDE
+)
+
+_TOOL_BUDGET_MID_NUDGE = (
+    "You have now made {n} tool calls. If you have gathered enough "
+    "context to identify findings, begin converging toward your final JSON output block "
+    "now rather than continuing to explore."
+)
+_TOOL_BUDGET_FINAL_NUDGE = (
+    "You have now made {n} tool calls. Stop reading and searching now, and emit "
+    "your final JSON output block with whatever you have found so far. If you have "
+    "found nothing, emit your final JSON output block with an empty findings list."
+)
+
+
+def _make_tool_budget_nudge_hooks(
+    label: str | None = None,
+    *,
+    mid_threshold: int = _TOOL_BUDGET_MID_THRESHOLD,
+    final_threshold: int = _TOOL_BUDGET_FINAL_THRESHOLD,
+) -> dict[HookEvent, list[HookMatcher]]:
+    """Create PostToolUse and PostToolUseFailure hooks that inject non-blocking
+    nudge warnings into Claude-path sessions when tool-call counts cross budget thresholds.
+
+    In claude-agent-sdk 0.1.81, supported tool-lifecycle hooks that can inject
+    feedback via hookSpecificOutput.additionalContext are PostToolUse and
+    PostToolUseFailure. PostToolBatch is the exact-per-turn future option in
+    Claude Code, but is untyped and unsupported in this SDK version.
+
+    One callback is shared by both events, closing over combined tool-call count
+    and one-shot flags. Subagent tool calls (bearing agent_id) are skipped.
+    """
+    tool_call_count = 0
+    mid_nudge_sent = False
+    final_nudge_sent = False
+
+    async def _hook_callback(
+        input_data: Any,
+        tool_use_id: str | None,
+        context: HookContext,
+    ) -> SyncHookJSONOutput:
+        nonlocal tool_call_count, mid_nudge_sent, final_nudge_sent
+        try:
+            if not isinstance(input_data, dict):
+                return {}
+            # Sub-agent attribution: skip Task-spawned subagents
+            if input_data.get("agent_id"):
+                return {}
+
+            tool_call_count += 1
+            nudge_message: str | None = None
+
+            if tool_call_count >= final_threshold and not final_nudge_sent:
+                final_nudge_sent = True
+                mid_nudge_sent = True
+                nudge_message = _TOOL_BUDGET_FINAL_NUDGE.format(n=tool_call_count)
+            elif tool_call_count >= mid_threshold and not mid_nudge_sent:
+                mid_nudge_sent = True
+                nudge_message = _TOOL_BUDGET_MID_NUDGE.format(n=tool_call_count)
+
+            if nudge_message is None:
+                return {}
+
+            event_name = input_data.get("hook_event_name")
+            logger.info(
+                "Injected Claude tool-budget nudge [%s] at tool call %d (event=%s)",
+                label or "unlabeled",
+                tool_call_count,
+                event_name,
+            )
+
+            # Mirror hook_event_name in hookSpecificOutput
+            if event_name == "PostToolUseFailure":
+                failure_output: PostToolUseFailureHookSpecificOutput = {
+                    "hookEventName": "PostToolUseFailure",
+                    "additionalContext": nudge_message,
+                }
+                return {"hookSpecificOutput": failure_output}
+            else:
+                success_output: PostToolUseHookSpecificOutput = {
+                    "hookEventName": "PostToolUse",
+                    "additionalContext": nudge_message,
+                }
+                return {"hookSpecificOutput": success_output}
+
+        except Exception:
+            logger.warning(
+                "Tool budget hook callback failed for [%s]",
+                label or "unlabeled",
+                exc_info=True,
+            )
+            return {}
+
+    matcher = HookMatcher(hooks=[_hook_callback])
+    return {
+        "PostToolUse": [matcher],
+        "PostToolUseFailure": [matcher],
+    }
+
+
 # Fallback repo root for ClaudeSDKClient cwd — used when no SHA-pinned
 # worktree has been provisioned (e.g. local dev runs, tests, subprocess
 # worker). In production, callers pass an explicit repo_root provisioned
@@ -1697,15 +1859,22 @@ async def _run_claude_session(
     betas: list[Literal["context-1m-2025-08-07"]] = (
         ["context-1m-2025-08-07"] if _attach_1m_context_beta else []
     )
+    system_prompt = (
+        system_prompt
+        + "\n\n"
+        + _TURN_BUDGET_SYSTEM_PROMPT_LINE_CLAUDE.format(max_turns=_MAX_TURNS_CLAUDE)
+    )
+    hooks = _make_tool_budget_nudge_hooks(label)
     options = ClaudeAgentOptions(
         cwd=effective_root,
         allowed_tools=["Read", "Glob", "Grep"] + context7_tools,
         mcp_servers=mcp_servers,
         strict_mcp_config=True,
         permission_mode="default",
+        hooks=hooks,
         model=model,
         system_prompt=system_prompt,
-        max_turns=_MAX_TURNS,
+        max_turns=_MAX_TURNS_CLAUDE,
         env=dict([settings.anthropic_credential]),
         stderr=_stderr_handler,
         betas=betas,
@@ -1743,6 +1912,11 @@ async def _run_claude_session(
         result_text = ""
         cost_usd = 0.0
         tool_calls: list[str] = []
+        # Note: message_index counts AssistantMessage objects received from the SDK
+        # stream, NOT CLI turns. Multiple AssistantMessage objects can occur within
+        # a single turn or sub-step. It must never be used as a turn counter.
+        # Key and log names ('msg_index', 'msg=%d') are preserved for log
+        # compatibility.
         message_index = 0
         failure_reason: Literal["turn_budget_exhausted"] | None = None
         async for message in client.receive_response():
@@ -1842,7 +2016,7 @@ async def _run_claude_session(
                     logger.warning(
                         "Agent [%s] exhausted its %d-turn budget (subtype=%s)",
                         label or "unlabeled",
-                        _MAX_TURNS,
+                        _MAX_TURNS_CLAUDE,
                         message.subtype,
                     )
                     failure_reason = "turn_budget_exhausted"

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/tests/test_config.py

@@ -214,11 +214,11 @@ def test_gemini_cache_ttl_override(monkeypatch: pytest.MonkeyPatch) -> None:
     assert settings.ARGUS_GEMINI_CACHE_TTL == 60
 
 
-def test_session_timeout_defaults_to_900(monkeypatch: pytest.MonkeyPatch) -> None:
+def test_session_timeout_defaults_to_1500(monkeypatch: pytest.MonkeyPatch) -> None:
     _set_required(monkeypatch)
     monkeypatch.delenv("ARGUS_SESSION_TIMEOUT", raising=False)
     settings = get_settings()
-    assert settings.ARGUS_SESSION_TIMEOUT == 900
+    assert settings.ARGUS_SESSION_TIMEOUT == 1500
 
 
 def test_session_timeout_override(monkeypatch: pytest.MonkeyPatch) -> None:

{argus_code_review-0.2.7 → argus_code_review-0.2.8}/tests/test_openai_runner.py

@@ -34,8 +34,12 @@ from openai.types.responses.response_usage import InputTokensDetails, OutputToke
 
 from argus.bench import BenchEntry
 from argus.llm.models import resolve as resolve_alias
-from argus.openai_runner import _redact_openai_inputs, run_session_openai
-from argus.runners import _MAX_TURNS, _TURN_BUDGET_SYSTEM_PROMPT_LINE
+from argus.openai_runner import (
+    _MAX_TURNS_OPENAI,
+    _redact_openai_inputs,
+    run_session_openai,
+)
+from argus.runners import _TURN_BUDGET_SYSTEM_PROMPT_LINE
 
 pytestmark = pytest.mark.asyncio
 
@@ -44,7 +48,9 @@ def _with_turn_budget_line(system_prompt: str) -> str:
     """The runner appends the shared turn-budget disclosure to every system
     prompt it's given -- tests that assert on the exact `instructions` sent
     to the API must account for it."""
-    return system_prompt + "\n\n" + _TURN_BUDGET_SYSTEM_PROMPT_LINE.format(max_turns=_MAX_TURNS)
+    return (
+        system_prompt + "\n\n" + _TURN_BUDGET_SYSTEM_PROMPT_LINE.format(max_turns=_MAX_TURNS_OPENAI)
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -292,15 +298,16 @@ class TestOpenAIRunnerBasicLoop:
         assert outputs[1]["call_id"] == "call_2"
 
     async def test_exhausting_max_turns_still_returns_a_result(self, tmp_path: Any) -> None:
-        """Exhausting _MAX_TURNS stops and builds whatever findings were
+        """Exhausting _MAX_TURNS_OPENAI stops and builds whatever findings were
         reported, with failure_reason="turn_budget_exhausted" -- not None,
         which would be indistinguishable from a clean 0-finding completion.
         """
-        from argus.runners import _MAX_TURNS
+        from argus.openai_runner import _MAX_TURNS_OPENAI
 
         finding_call = ("report_finding", {"file": "f.py", "line": 1, "description": "d"})
         responses = [
-            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS + 5)
+            _make_response(calls=[finding_call], resp_id=f"r_{i}")
+            for i in range(_MAX_TURNS_OPENAI + 5)
         ]
         client = _make_fake_client(responses)
         entry = _make_entry()
@@ -315,29 +322,30 @@ class TestOpenAIRunnerBasicLoop:
             )
 
         assert result.failure_reason == "turn_budget_exhausted"
-        assert client.responses.create.call_count == _MAX_TURNS
+        assert client.responses.create.call_count == _MAX_TURNS_OPENAI
         from argus.helpers import parse_review_result
 
         parsed = parse_review_result(result.result_text, "test-group")
-        assert len(parsed.findings) == _MAX_TURNS
+        assert len(parsed.findings) == _MAX_TURNS_OPENAI
 
     async def test_finish_review_on_final_turn_is_clean_completion_not_exhaustion(
         self, tmp_path: Any
     ) -> None:
-        """A successful finish_review on the LAST allowed turn (_MAX_TURNS) must
+        """A successful finish_review on the LAST allowed turn (_MAX_TURNS_OPENAI) must
         still be treated as a clean completion with files_explored populated.
         The turn loop's `for...else` only runs its exhaustion branch when the loop
         completes without `break`."""
-        from argus.runners import _MAX_TURNS
+        from argus.openai_runner import _MAX_TURNS_OPENAI
 
         finding_call = ("report_finding", {"file": "f.py", "line": 1, "description": "d"})
         responses = [
-            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS - 1)
+            _make_response(calls=[finding_call], resp_id=f"r_{i}")
+            for i in range(_MAX_TURNS_OPENAI - 1)
         ]
         responses.append(
             _make_response(
                 calls=[("finish_review", {"files_explored": ["f.py"]})],
-                resp_id=f"r_{_MAX_TURNS - 1}",
+                resp_id=f"r_{_MAX_TURNS_OPENAI - 1}",
             )
         )
         client = _make_fake_client(responses)
@@ -353,18 +361,19 @@ class TestOpenAIRunnerBasicLoop:
             )
 
         assert result.failure_reason is None
-        assert client.responses.create.call_count == _MAX_TURNS
+        assert client.responses.create.call_count == _MAX_TURNS_OPENAI
         assert "finish_review" in result.tool_names
 
     async def test_nudge_injected_once_at_turn_budget_minus_three(self, tmp_path: Any) -> None:
         """A session that never calls finish_review gets nudged exactly once,
         _NUDGE_TURNS_BEFORE_BUDGET turns before exhaustion, and still preserves
         findings reported both before and after the nudge."""
-        from argus.runners import _MAX_TURNS, _NUDGE_TURNS_BEFORE_BUDGET, _TURN_BUDGET_NUDGE
+        from argus.openai_runner import _MAX_TURNS_OPENAI
+        from argus.runners import _NUDGE_TURNS_BEFORE_BUDGET, _TURN_BUDGET_NUDGE
 
         finding_call = ("report_finding", {"file": "f.py", "line": 1, "description": "d"})
         responses = [
-            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS)
+            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS_OPENAI)
         ]
         client = _make_fake_client(responses)
         entry = _make_entry()
@@ -382,9 +391,9 @@ class TestOpenAIRunnerBasicLoop:
         from argus.helpers import parse_review_result
 
         parsed = parse_review_result(result.result_text, "test-group")
-        assert len(parsed.findings) == _MAX_TURNS
+        assert len(parsed.findings) == _MAX_TURNS_OPENAI
 
-        threshold = _MAX_TURNS - _NUDGE_TURNS_BEFORE_BUDGET
+        threshold = _MAX_TURNS_OPENAI - _NUDGE_TURNS_BEFORE_BUDGET
         nudge_item = {"role": "user", "content": _TURN_BUDGET_NUDGE}
         for i, call in enumerate(client.responses.create.call_args_list):
             call_input = call.kwargs["input"]
@@ -421,13 +430,14 @@ class TestOpenAIRunnerBasicLoop:
 
     async def test_mid_budget_nudge_injected_once_at_75_percent(self, tmp_path: Any) -> None:
         """A session that never calls finish_review gets the mid-budget
-        checkpoint nudge exactly once, at 75% of _MAX_TURNS -- in addition
+        checkpoint nudge exactly once, at 75% of _MAX_TURNS_OPENAI -- in addition
         to (not instead of) the end-of-budget _TURN_BUDGET_NUDGE."""
-        from argus.runners import _MAX_TURNS, _MID_BUDGET_NUDGE, _compute_mid_budget_nudge_turn
+        from argus.openai_runner import _MAX_TURNS_OPENAI
+        from argus.runners import _MID_BUDGET_NUDGE, _compute_mid_budget_nudge_turn
 
         finding_call = ("report_finding", {"file": "f.py", "line": 1, "description": "d"})
         responses = [
-            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS)
+            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS_OPENAI)
         ]
         client = _make_fake_client(responses)
         entry = _make_entry()
@@ -443,7 +453,7 @@ class TestOpenAIRunnerBasicLoop:
 
         assert result.failure_reason == "turn_budget_exhausted"
 
-        mid_budget_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS)
+        mid_budget_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS_OPENAI)
         assert mid_budget_turn is not None
         nudge_item = {"role": "user", "content": _MID_BUDGET_NUDGE}
         for i, call in enumerate(client.responses.create.call_args_list):
@@ -485,8 +495,8 @@ class TestOpenAIRunnerBasicLoop:
         """An exhausted session must receive BOTH the mid-budget checkpoint
         nudge and the end-of-budget emergency nudge, at their own distinct
         turns -- neither should suppress or overwrite the other."""
+        from argus.openai_runner import _MAX_TURNS_OPENAI
         from argus.runners import (
-            _MAX_TURNS,
             _MID_BUDGET_NUDGE,
             _NUDGE_TURNS_BEFORE_BUDGET,
             _TURN_BUDGET_NUDGE,
@@ -495,7 +505,7 @@ class TestOpenAIRunnerBasicLoop:
 
         finding_call = ("report_finding", {"file": "f.py", "line": 1, "description": "d"})
         responses = [
-            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS)
+            _make_response(calls=[finding_call], resp_id=f"r_{i}") for i in range(_MAX_TURNS_OPENAI)
         ]
         client = _make_fake_client(responses)
         entry = _make_entry()
@@ -511,8 +521,8 @@ class TestOpenAIRunnerBasicLoop:
 
         assert result.failure_reason == "turn_budget_exhausted"
 
-        mid_budget_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS)
-        emergency_turn = _MAX_TURNS - _NUDGE_TURNS_BEFORE_BUDGET
+        mid_budget_turn = _compute_mid_budget_nudge_turn(_MAX_TURNS_OPENAI)
+        emergency_turn = _MAX_TURNS_OPENAI - _NUDGE_TURNS_BEFORE_BUDGET
         assert mid_budget_turn is not None
         assert mid_budget_turn != emergency_turn
 
@@ -957,8 +967,8 @@ class TestOpenAIRunnerTimeoutsAndFailures:
         mock_init.assert_called_once()
         assert mock_init.call_args.kwargs["timeout"] == 42.0
 
-    async def test_default_timeout_is_900_seconds(self, tmp_path: Any) -> None:
-        """When neither timeout_s nor ARGUS_SESSION_TIMEOUT is passed, defaults to 900s."""
+    async def test_default_timeout_is_1500_seconds(self, tmp_path: Any) -> None:
+        """When neither timeout_s nor ARGUS_SESSION_TIMEOUT is passed, defaults to 1500s."""
         settings = MagicMock(spec=[])
         settings.OPENAI_API_KEY = "key"
         client = _make_fake_client([_make_response(calls=[])])
@@ -974,7 +984,7 @@ class TestOpenAIRunnerTimeoutsAndFailures:
             )
 
         mock_init.assert_called_once()
-        assert mock_init.call_args.kwargs["timeout"] == 900
+        assert mock_init.call_args.kwargs["timeout"] == 1500
 
     async def test_client_closed_on_normal_completion(self, tmp_path: Any) -> None:
         """client.close is called when session completes normally."""