claude-code-generator 0.4.10__tar.gz → 0.4.12__tar.gz

{claude_code_generator-0.4.10/src/claude_code_generator.egg-info → claude_code_generator-0.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.10
+Version: 0.4.12
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.4.10 → claude_code_generator-0.4.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.10"
+version = "0.4.12"
 description = "Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file."
 readme = "README.md"
 license = { text = "MIT" }

{claude_code_generator-0.4.10 → claude_code_generator-0.4.12/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.10
+Version: 0.4.12
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.4.10 → claude_code_generator-0.4.12}/src/code_generator/__init__.py

@@ -1,3 +1,3 @@
 """code-generator: orchestrator CLI for end-to-end project generation."""
 
-__version__ = "0.4.10"
+__version__ = "0.4.12"

claude_code_generator-0.4.12/src/code_generator/orchestrator/ollama_budget.py

@@ -0,0 +1,215 @@
+"""Per-cycle safety backstop for the Ollama codepath.
+
+The pre-0.4.11 design treated ``OLLAMA_TURN_BUDGET`` as a hard abort trigger
+— cycles were aborted after exactly 200 turns regardless of whether the
+model was making progress. That is the wrong layer: actual fault-detection
+already lives in two places and triggers on real malfunctions, not on an
+arbitrary counter:
+
+  * :class:`~code_generator.runner.retry.CircuitBreaker` — trips after ``N``
+    consecutive failures on a single phase call. Already wrapped around
+    Phase 2 (per-issue / batched review), Phase 3/4 (TDD implementation),
+    and Phase 5 (closure).
+  * :func:`~code_generator.runner.rate_limit.handle_ollama_429` —
+    wait-and-resume on 429s returned by the Ollama daemon.
+
+This module therefore degrades to a **non-blocking adaptive** backstop:
+
+  * The turn counter now emits a single **WARNING** when the cycle crosses
+    the soft threshold (default 500). The pipeline is **never** aborted on
+    the turn count alone. Weak open models are chatty by design; letting
+    them run is the right call.
+  * The wall-clock cap remains a **hard abort**, but the default is raised
+    to 4 hours. It exists purely to catch a stuck daemon or a model trapped
+    in a pathological loop the CircuitBreaker cannot see (e.g. infinite
+    ``end_turn``→``continue`` cycle producing no tool calls).
+
+Both thresholds are env-overridable:
+
+  * ``OLLAMA_SOFT_TURN_WARN``  (int, positive; default 500)
+  * ``OLLAMA_WALLCLOCK_BUDGET_SECONDS``  (int, positive; default 14400)
+
+Backwards-compatible shim: the old ``OLLAMA_TURN_BUDGET`` env variable is
+still honoured and maps onto the soft-warn threshold, so operators with
+existing scripts see no behaviour change beyond the abort becoming a
+warning.
+
+Nothing is persisted in ``state.json`` — the tracker is per-run and
+discarded on abort or clean completion.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from code_generator.state import CycleState, State
+
+_logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Threshold constants
+# ---------------------------------------------------------------------------
+
+_DEFAULT_SOFT_TURN_WARN = 500
+_DEFAULT_WALLCLOCK_BUDGET_SECONDS = 14400  # 4 h
+
+
+def _read_int_env(name: str, default: int) -> int:
+    """Parse a positive int from the environment, falling back to *default*.
+
+    Invalid values (empty, non-numeric, zero, or negative) are silently
+    replaced with *default* — these are per-run tuning knobs, not safety
+    gates, so noisy error handling would surprise operators who meant well.
+    """
+    raw = os.environ.get(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        return default
+    return value if value > 0 else default
+
+
+def _resolve_soft_turn_warn() -> int:
+    """Honour the legacy ``OLLAMA_TURN_BUDGET`` env var for backwards compat."""
+    legacy = _read_int_env("OLLAMA_TURN_BUDGET", 0)
+    if legacy:
+        return legacy
+    return _read_int_env("OLLAMA_SOFT_TURN_WARN", _DEFAULT_SOFT_TURN_WARN)
+
+
+OLLAMA_SOFT_TURN_WARN = _resolve_soft_turn_warn()
+"""Soft warning threshold on per-cycle ``num_turns``.
+
+Defaults to 500. Override via ``OLLAMA_SOFT_TURN_WARN`` (new name) or the
+legacy ``OLLAMA_TURN_BUDGET`` (preserved for backwards compatibility). The
+value is **non-blocking**: the pipeline only logs a WARNING once per cycle
+when the cumulative turn count first crosses this threshold. It never
+aborts.
+"""
+
+# Kept as a module-level alias so existing importers (tests, scripts) keep
+# working. The semantics are now "soft warning threshold", not "abort".
+OLLAMA_TURN_BUDGET = OLLAMA_SOFT_TURN_WARN
+"""Backwards-compatible alias for :data:`OLLAMA_SOFT_TURN_WARN`."""
+
+OLLAMA_WALLCLOCK_BUDGET_SECONDS = _read_int_env(
+    "OLLAMA_WALLCLOCK_BUDGET_SECONDS", _DEFAULT_WALLCLOCK_BUDGET_SECONDS
+)
+"""Hard wall-clock abort threshold (seconds) per cycle on the Ollama codepath.
+
+Defaults to 14400 (4 h); override via ``OLLAMA_WALLCLOCK_BUDGET_SECONDS``.
+This is the only hard abort enforced by this module — it exists to catch a
+stuck daemon or a pathological loop the per-phase
+:class:`~code_generator.runner.retry.CircuitBreaker` cannot see.
+"""
+
+
+# ---------------------------------------------------------------------------
+# Exception
+# ---------------------------------------------------------------------------
+
+
+class OllamaBudgetExceeded(RuntimeError):
+    """Raised when the Ollama per-cycle wall-clock backstop is exceeded.
+
+    Only fires on the wall-clock path. The turn counter now emits a WARNING
+    instead; real per-call failures are handled by the ``CircuitBreaker``
+    in :mod:`code_generator.runner.retry`.
+
+    Subclasses ``RuntimeError`` to match the existing safety-abort hierarchy
+    (e.g. :class:`~code_generator.runner.types.OverageAbort`).
+    """
+
+
+# ---------------------------------------------------------------------------
+# Tracker
+# ---------------------------------------------------------------------------
+
+
+class OllamaBudgetTracker:
+    """Adaptive per-cycle safety backstop; a no-op on the Anthropic Max path.
+
+    Emits one WARNING when the cycle crosses the soft turn threshold; aborts
+    only on the wall-clock backstop. Does **not** block the pipeline on the
+    turn count — real failures are the responsibility of
+    :class:`~code_generator.runner.retry.CircuitBreaker` and the rate-limit
+    handlers in :mod:`code_generator.runner.rate_limit`.
+    """
+
+    def __init__(
+        self,
+        *,
+        provider_is_ollama: bool,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        """Initialise a tracker; call :meth:`start` at cycle kickoff.
+
+        Args:
+            provider_is_ollama: When False every :meth:`check` call is a
+                no-op so the Anthropic Max path stays byte-for-byte unchanged.
+            clock: Injectable monotonic clock for deterministic tests;
+                defaults to ``time.monotonic``.
+        """
+        self._active = provider_is_ollama
+        self._clock = clock or time.monotonic
+        self._start_time: float | None = None
+        self._turn_warning_emitted = False
+
+    def start(self) -> None:
+        """Record the cycle start time. Idempotent; only the first call matters."""
+        if self._active and self._start_time is None:
+            self._start_time = self._clock()
+
+    def check(self, state: State, cycle: CycleState | None) -> None:
+        """Warn on soft-turn threshold; raise only on wall-clock overflow."""
+        if not self._active:
+            return
+        self._check_turn_soft_warn(state, cycle)
+        self._check_wallclock_budget()
+
+    def _check_turn_soft_warn(self, state: State, cycle: CycleState | None) -> None:
+        """Emit one WARNING the first time the cycle crosses the soft threshold.
+
+        Never raises. Subsequent checks in the same cycle are no-ops because
+        the warning flag is sticky until the tracker is discarded.
+        """
+        if self._turn_warning_emitted:
+            return
+        total = _sum_num_turns(state, cycle)
+        if total > OLLAMA_SOFT_TURN_WARN:
+            _logger.warning(
+                "Ollama cycle has consumed %d turns (soft threshold: %d). "
+                "Letting it run — real failures are caught by the per-phase "
+                "CircuitBreaker in runner/retry.py. Raise the threshold via "
+                "OLLAMA_SOFT_TURN_WARN or the legacy OLLAMA_TURN_BUDGET env "
+                "var to silence this warning.",
+                total,
+                OLLAMA_SOFT_TURN_WARN,
+            )
+            self._turn_warning_emitted = True
+
+    def _check_wallclock_budget(self) -> None:
+        if self._start_time is None:
+            return
+        elapsed = self._clock() - self._start_time
+        if elapsed > OLLAMA_WALLCLOCK_BUDGET_SECONDS:
+            raise OllamaBudgetExceeded(
+                f"Ollama wall-clock budget exceeded: {elapsed:.0f}s > "
+                f"{OLLAMA_WALLCLOCK_BUDGET_SECONDS}s. "
+                "Raise OLLAMA_WALLCLOCK_BUDGET_SECONDS (env var) if real "
+                "workloads legitimately need more than 4 hours per cycle."
+            )
+
+
+def _sum_num_turns(state: State, cycle: CycleState | None) -> int:
+    """Sum ``num_turns`` across every phase of the active cycle (or state)."""
+    source = cycle.token_usage if cycle is not None else state.token_usage
+    return sum(usage.num_turns for usage in source.values())

{claude_code_generator-0.4.10 → claude_code_generator-0.4.12}/src/code_generator/orchestrator/phase1_plan.py

@@ -116,6 +116,47 @@ _PHASE1_DEFAULT_MODEL = "claude-opus-4-7"
 # CLAUDE.md invariant #8; overridden via ``effective_model`` on Ollama — #219.
 
 
+_PHASE1_MAX_ATTEMPTS = 3
+"""Max planning attempts before surfacing ``Phase1NoIssuesError`` (0.4.12).
+
+Weak open models on the Ollama codepath often respond with prose describing
+the plan instead of invoking ``gh issue create`` via the Bash tool. A single
+stricter re-prompt is usually enough to unblock them without operator
+intervention.
+"""
+
+
+_PHASE1_RETRY_NUDGE = (
+    "Your previous attempt finished without creating any GitHub issues. "
+    "This is a CRITICAL failure. You MUST use the Bash tool to invoke "
+    "`gh issue create` for each issue right now. Do NOT output markdown "
+    "or prose describing the plan — every planned issue must become a "
+    "real GitHub issue via `gh issue create ... --milestone "
+    '"{MILESTONE}" --assignee @me --label "..."`. Once you have called '
+    "`gh issue create` for every planned issue, print a one-line summary "
+    "per issue and stop.\n\n"
+    "The original instructions follow.\n\n"
+)
+
+
+def _accumulate_usage(
+    total: _state.TokenUsage | None,
+    delta: _state.TokenUsage,
+) -> _state.TokenUsage:
+    """Sum two TokenUsage records field-by-field across Phase 1 attempts."""
+    from code_generator.runner.types import TokenUsage
+
+    if total is None:
+        return delta
+    return TokenUsage(
+        input=total.input + delta.input,
+        output=total.output + delta.output,
+        cache_read=total.cache_read + delta.cache_read,
+        cache_write=total.cache_write + delta.cache_write,
+        num_turns=total.num_turns + delta.num_turns,
+    )
+
+
 def _load_specialized_prompt(
     project_dir: Path,
     state: State,
@@ -249,28 +290,56 @@ async def run(
             **max_turns_kwargs(max_turns),
         )
 
-        result = await rate_limit.main_loop(
-            runner_module,
-            prompt,
-            options,
-            state_path=state_path,
-            logger=logger,
-        )
+        # Up to _PHASE1_MAX_ATTEMPTS attempts: the first with the normal
+        # prompt, subsequent attempts prefixed with a stricter nudge that
+        # tells the model to use the Bash tool to call ``gh issue create``
+        # right now. Weak open models on the Ollama codepath commonly
+        # respond with prose on the first turn; the nudge recovers most
+        # of those cases without operator intervention (0.4.12).
+        issue_states: list[_state.IssueState] = []
+        total_usage = result = None  # type: ignore[assignment]
+        attempt_prompt = prompt
+        effective_model_name = effective_model or _PHASE1_DEFAULT_MODEL
+        for attempt in range(1, _PHASE1_MAX_ATTEMPTS + 1):
+            result = await rate_limit.main_loop(
+                runner_module,
+                attempt_prompt,
+                options,
+                state_path=state_path,
+                logger=logger,
+            )
+            total_usage = _accumulate_usage(total_usage, result.usage)
 
-        # Fetch all issues in the milestone (open + closed) to support deduplication.
-        raw_issues = gh.list_issues(
-            repo,
-            milestone=milestone_title,
-            state="all",
-        )
-        issue_states = _build_issue_states(raw_issues)
+            raw_issues = gh.list_issues(
+                repo,
+                milestone=milestone_title,
+                state="all",
+            )
+            issue_states = _build_issue_states(raw_issues)
+            if issue_states:
+                break
+
+            if attempt >= _PHASE1_MAX_ATTEMPTS:
+                break
+
+            logger.warning(
+                "Phase 1 attempt %d/%d: model returned without creating any "
+                "GitHub issues. Re-prompting with a stricter nudge.",
+                attempt,
+                _PHASE1_MAX_ATTEMPTS,
+            )
+            nudge = _PHASE1_RETRY_NUDGE.replace("{MILESTONE}", milestone_title or "")
+            attempt_prompt = nudge + prompt
 
         if not issue_states:
             raise Phase1NoIssuesError(
-                "Phase 1 finished without creating any GitHub issues. "
-                "Opus likely misread the task (e.g. audited existing code instead "
-                "of planning new work). Inspect .code-generator/logs/phase1.log, "
-                "adjust prompt-phase-1-planning.md if needed, and re-run."
+                f"Phase 1 finished without creating any GitHub issues after "
+                f"{_PHASE1_MAX_ATTEMPTS} attempts (model={effective_model_name!r}). "
+                "The model likely responded with prose instead of invoking "
+                "`gh issue create` via the Bash tool. Inspect "
+                ".code-generator/logs/phase1.log for the tool-call trace, "
+                "try a stronger model, or simplify the cycle scope in "
+                "requirements.md and re-run."
             )
 
         target = cycle if cycle is not None else state
@@ -278,12 +347,17 @@ async def run(
             cycle.issues = issue_states
         else:
             state.issues = issue_states
-        target.token_usage["phase1"] = result.usage
+        # Persist the accumulated usage across all attempts (not just the last).
+        target.token_usage["phase1"] = total_usage if total_usage is not None else result.usage
         if hasattr(target, "cache_telemetry"):
-            accumulate_telemetry(target.cache_telemetry, result.usage, result.wall_seconds)
+            accumulate_telemetry(
+                target.cache_telemetry,
+                target.token_usage["phase1"],
+                result.wall_seconds,
+            )
 
         _state.save_state(state_path, state)
-        log_phase_usage(logger, 1, result.usage)
+        log_phase_usage(logger, 1, target.token_usage["phase1"])
         logger.info("Phase 1: %d issues created.", len(issue_states))
 
     except Exception:

{claude_code_generator-0.4.10 → claude_code_generator-0.4.12}/tests/test_ollama_budget.py

@@ -1,22 +1,23 @@
-"""Tests for Ollama per-cycle budget enforcement (issue #220).
+"""Tests for the Ollama per-cycle adaptive safety backstop (issue #220, 0.4.11).
 
-TDD: Red → Green.
+As of 0.4.11 the turn counter is a **non-blocking soft warning** — the
+pipeline is never aborted on turn count alone. Real per-call failures are
+the job of :class:`~code_generator.runner.retry.CircuitBreaker` and the
+rate-limit handlers. The wall-clock remains a hard abort (default 4 h).
 
-On the Ollama codepath (``effective_model`` is not ``None``) the orchestrator
-substitutes non-negotiable #4's overage-abort with two explicit budgets:
-turn count and wall-clock. The Anthropic Max path is untouched.
-
-Turn accumulation reads from ``state.token_usage[<phase>].num_turns`` (or
-``cycle.token_usage[<phase>].num_turns`` when a cycle is active), which
-#204/#205 already populate on every phase run.
+Backwards compatibility: ``OLLAMA_TURN_BUDGET`` is preserved as an alias
+for :data:`OLLAMA_SOFT_TURN_WARN` so existing scripts keep importing.
 """
 
 from __future__ import annotations
 
+import logging
+
 import pytest
 
 from code_generator import state as _state
 from code_generator.orchestrator.ollama_budget import (
+    OLLAMA_SOFT_TURN_WARN,
     OLLAMA_TURN_BUDGET,
     OLLAMA_WALLCLOCK_BUDGET_SECONDS,
     OllamaBudgetExceeded,
@@ -29,12 +30,16 @@ from code_generator.runner.types import TokenUsage
 # ---------------------------------------------------------------------------
 
 
-class TestBudgetConstants:
-    def test_turn_budget_default_is_200(self) -> None:
-        assert OLLAMA_TURN_BUDGET == 200
+class TestThresholdConstants:
+    def test_soft_turn_warn_default_is_500(self) -> None:
+        assert OLLAMA_SOFT_TURN_WARN == 500
 
-    def test_wallclock_budget_default_is_3600_seconds(self) -> None:
-        assert OLLAMA_WALLCLOCK_BUDGET_SECONDS == 3600
+    def test_turn_budget_alias_matches_soft_turn_warn(self) -> None:
+        """Legacy ``OLLAMA_TURN_BUDGET`` must alias the new soft-warn constant."""
+        assert OLLAMA_TURN_BUDGET == OLLAMA_SOFT_TURN_WARN
+
+    def test_wallclock_budget_default_is_4_hours(self) -> None:
+        assert OLLAMA_WALLCLOCK_BUDGET_SECONDS == 14400
 
 
 # ---------------------------------------------------------------------------
@@ -69,69 +74,78 @@ def _make_state_with_usage(
 
 
 # ---------------------------------------------------------------------------
-# Turn-count budget
+# Soft-turn warning
 # ---------------------------------------------------------------------------
 
 
-class TestTurnBudget:
-    def test_under_budget_does_not_raise(self) -> None:
-        """When total num_turns is below the budget, check() is a no-op."""
+class TestTurnSoftWarning:
+    def test_under_threshold_does_not_warn(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Below the soft threshold → no WARNING emitted, no raise."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase1": 50, "phase2": 80})
         tracker = OllamaBudgetTracker(provider_is_ollama=True)
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
 
-    def test_exactly_at_budget_does_not_raise(self) -> None:
-        """The budget is strict-greater-than, so equal to the cap passes."""
-        st, cycle = _make_state_with_usage({}, cycle_turns={"phase3_4": OLLAMA_TURN_BUDGET})
+        turn_warnings = [r for r in caplog.records if "turns" in r.message.lower()]
+        assert turn_warnings == []
+
+    def test_over_threshold_warns_without_raising(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Crossing the soft threshold logs a WARNING; the pipeline continues."""
+        st, cycle = _make_state_with_usage(
+            {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN + 100}
+        )
         tracker = OllamaBudgetTracker(provider_is_ollama=True)
 
-        tracker.check(st, cycle)  # must not raise at ==
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)  # must not raise
 
-    def test_over_budget_raises_with_exact_message(self) -> None:
-        """Exceeding the turn budget raises OllamaBudgetExceeded naming the budget."""
-        st, cycle = _make_state_with_usage({}, cycle_turns={"phase3_4": OLLAMA_TURN_BUDGET + 1})
+        turn_warnings = [r for r in caplog.records if "consumed" in r.message.lower()]
+        assert len(turn_warnings) == 1
+        msg = turn_warnings[0].message
+        assert str(OLLAMA_SOFT_TURN_WARN + 100) in msg
+        assert str(OLLAMA_SOFT_TURN_WARN) in msg
+
+    def test_warning_is_emitted_only_once_per_cycle(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Subsequent checks after the first warning must stay silent."""
+        st, cycle = _make_state_with_usage(
+            {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN + 100}
+        )
         tracker = OllamaBudgetTracker(provider_is_ollama=True)
 
-        with pytest.raises(OllamaBudgetExceeded) as excinfo:
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+            tracker.check(st, cycle)
             tracker.check(st, cycle)
 
-        msg = str(excinfo.value)
-        assert "turn" in msg.lower()
-        assert str(OLLAMA_TURN_BUDGET) in msg
-        assert str(OLLAMA_TURN_BUDGET + 1) in msg
+        turn_warnings = [r for r in caplog.records if "consumed" in r.message.lower()]
+        assert len(turn_warnings) == 1
 
-    def test_turns_aggregate_across_phases(self) -> None:
-        """num_turns from every phase sum toward the per-cycle budget."""
+    def test_turns_aggregate_across_phases(self, caplog: pytest.LogCaptureFixture) -> None:
+        """num_turns from every phase sum toward the soft threshold."""
         st, cycle = _make_state_with_usage(
             {},
             cycle_turns={
-                "phase0": 50,
-                "phase1": 30,
-                "phase2": 30,
-                "phase3_4": 60,
-                "phase5": 20,
-                "phase6": 10,
-                "phase7": 5,
+                "phase0": 100,
+                "phase1": 80,
+                "phase2": 80,
+                "phase3_4": 200,
+                "phase5": 60,
+                "phase6": 20,
+                "phase7": 10,
             },
         )
-        # Sum = 205 > 200.
+        # Sum = 550 > 500.
         tracker = OllamaBudgetTracker(provider_is_ollama=True)
 
-        with pytest.raises(OllamaBudgetExceeded, match="205"):
-            tracker.check(st, cycle)
-
-    def test_single_mode_uses_state_token_usage_when_cycle_is_none(self) -> None:
-        """When ``cycle`` is None, total turns come from state.token_usage."""
-        st, _c = _make_state_with_usage({"phase0": OLLAMA_TURN_BUDGET + 5})
-        tracker = OllamaBudgetTracker(provider_is_ollama=True)
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)  # must not raise
 
-        with pytest.raises(OllamaBudgetExceeded, match="turn"):
-            tracker.check(st, cycle=None)
+        assert any("550" in r.message for r in caplog.records)
 
 
 # ---------------------------------------------------------------------------
-# Wall-clock budget
+# Wall-clock hard abort
 # ---------------------------------------------------------------------------
 
 
@@ -145,7 +159,6 @@ class TestWallclockBudget:
             clock=lambda: now,
         )
         tracker.start()
-        # Simulate time passage below the budget.
         now += OLLAMA_WALLCLOCK_BUDGET_SECONDS - 10
 
         tracker.check(st, cycle)  # must not raise
@@ -153,7 +166,6 @@ class TestWallclockBudget:
     def test_over_budget_raises_with_exact_message(self) -> None:
         """Elapsed > budget → OllamaBudgetExceeded naming wall-clock."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
-        # Use a small mutable clock to simulate time moving forward.
         t = [1_000_000.0]
 
         def _clock() -> float:
@@ -175,22 +187,36 @@ class TestWallclockBudget:
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=lambda: 1e12)
 
-        # No start() call; wall-clock assertion must skip. Turn check still runs.
-        tracker.check(st, cycle)  # must not raise (under turn budget, no start)
+        tracker.check(st, cycle)  # must not raise
+
+    def test_extreme_turn_count_does_not_raise(self) -> None:
+        """No amount of turns should raise on its own — only wall-clock hard-aborts."""
+        st, cycle = _make_state_with_usage(
+            {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN * 100}
+        )
+        tracker = OllamaBudgetTracker(provider_is_ollama=True)
+
+        tracker.check(st, cycle)  # must not raise
 
 
 # ---------------------------------------------------------------------------
-# Anthropic Max path — budgets do not fire
+# Anthropic Max path — thresholds do not fire
 # ---------------------------------------------------------------------------
 
 
 class TestAnthropicMaxUntouched:
-    def test_anthropic_max_mode_skips_turn_budget(self) -> None:
-        """provider_is_ollama=False → turn budget breach does not raise."""
-        st, cycle = _make_state_with_usage({}, cycle_turns={"phase3_4": OLLAMA_TURN_BUDGET + 100})
+    def test_anthropic_max_mode_skips_turn_warning(self, caplog: pytest.LogCaptureFixture) -> None:
+        """provider_is_ollama=False → no WARNING, no raise."""
+        st, cycle = _make_state_with_usage(
+            {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN + 100}
+        )
         tracker = OllamaBudgetTracker(provider_is_ollama=False)
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+
+        turn_warnings = [r for r in caplog.records if "consumed" in r.message.lower()]
+        assert turn_warnings == []
 
     def test_anthropic_max_mode_skips_wallclock_budget(self) -> None:
         """provider_is_ollama=False → wall-clock breach does not raise."""