claude-code-generator 0.4.9__tar.gz → 0.4.11__tar.gz

{claude_code_generator-0.4.9/src/claude_code_generator.egg-info → claude_code_generator-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.9
+Version: 0.4.11
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -32,6 +32,7 @@ Requires-Dist: tree-sitter>=0.23; extra == "repomap"
 Requires-Dist: tree-sitter-language-pack>=0.5; extra == "repomap"
 Provides-Extra: mcp
 Requires-Dist: mcp<2.0,>=1.0; extra == "mcp"
+Requires-Dist: serena-agent<2.0,>=1.1; extra == "mcp"
 Provides-Extra: batch
 Requires-Dist: anthropic>=0.35; extra == "batch"
 Provides-Extra: all

{claude_code_generator-0.4.9 → claude_code_generator-0.4.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.9"
+version = "0.4.11"
 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" }
@@ -47,11 +47,13 @@ repomap = [
     "tree-sitter-language-pack>=0.5",
 ]
 mcp = [
-    # Python MCP client library — the codebase-memory-mcp and serena binaries
-    # are external and must be installed separately:
-    #   cargo install codebase-memory-mcp   (or brew install codebase-memory-mcp)
-    #   pip install serena                  (or uvx serena for zero-install)
+    # Python MCP client library.
     "mcp>=1.0,<2.0",
+    # Serena MCP server (provides the `serena` executable on PATH —
+    # picked up by runner/mcp.py's shutil.which("serena") fallback).
+    # The primary server, codebase-memory-mcp, is a Rust crate and still
+    # must be installed separately: `cargo install codebase-memory-mcp`.
+    "serena-agent>=1.1,<2.0",
 ]
 batch = [
     # Anthropic SDK for the Messages Batches API (§6).
@@ -59,8 +61,10 @@ batch = [
     "anthropic>=0.35",
 ]
 all = [
-    # Everything pip can install. External binaries (codebase-memory-mcp Rust
-    # crate, serena) must be installed separately — see README.
+    # Everything pip can install: repomap (tree-sitter), MCP client + Serena
+    # MCP server, and the Anthropic Batches API. The primary MCP server
+    # codebase-memory-mcp is a Rust crate and must be installed separately:
+    #   cargo install codebase-memory-mcp
     "claude-code-generator[repomap,mcp,batch]",
 ]
 

{claude_code_generator-0.4.9 → claude_code_generator-0.4.11/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.9
+Version: 0.4.11
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT
@@ -32,6 +32,7 @@ Requires-Dist: tree-sitter>=0.23; extra == "repomap"
 Requires-Dist: tree-sitter-language-pack>=0.5; extra == "repomap"
 Provides-Extra: mcp
 Requires-Dist: mcp<2.0,>=1.0; extra == "mcp"
+Requires-Dist: serena-agent<2.0,>=1.1; extra == "mcp"
 Provides-Extra: batch
 Requires-Dist: anthropic>=0.35; extra == "batch"
 Provides-Extra: all

{claude_code_generator-0.4.9 → claude_code_generator-0.4.11}/src/claude_code_generator.egg-info/requires.txt

@@ -15,6 +15,7 @@ ruff
 
 [mcp]
 mcp<2.0,>=1.0
+serena-agent<2.0,>=1.1
 
 [repomap]
 tree-sitter>=0.23

{claude_code_generator-0.4.9 → claude_code_generator-0.4.11}/src/code_generator/__init__.py

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

claude_code_generator-0.4.11/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.9 → claude_code_generator-0.4.11}/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."""

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

@@ -1,116 +0,0 @@
-"""Per-cycle safety budgets for the Ollama codepath (issue #220).
-
-Ollama does not emit Anthropic's ``RateLimitEvent.info.overage_status``, so
-non-negotiable #4 (abort on overage) cannot fire on the Ollama codepath.
-This module substitutes the safety invariant with two explicit per-cycle
-budgets — a turn-count cap and a wall-clock cap — whose breaches raise
-:class:`OllamaBudgetExceeded` with a message naming which budget was hit.
-
-These caps are defensive defaults. Operators who regularly exceed them on
-real workloads should tune the module-level constants in one place rather
-than editing phase internals.
-
-Nothing is persisted in ``state.json`` — budgets are per-run enforcement,
-not cross-resume accounting. A fresh ``OllamaBudgetTracker`` is created
-for every cycle and discarded on abort or clean completion.
-"""
-
-from __future__ import annotations
-
-import time
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from code_generator.state import CycleState, State
-
-# ---------------------------------------------------------------------------
-# Budget constants
-# ---------------------------------------------------------------------------
-
-OLLAMA_TURN_BUDGET = 200
-"""Maximum num_turns allowed per cycle on the Ollama codepath."""
-
-OLLAMA_WALLCLOCK_BUDGET_SECONDS = 3600
-"""Maximum wall-clock elapsed (seconds) per cycle on the Ollama codepath (1 hour)."""
-
-
-# ---------------------------------------------------------------------------
-# Exception
-# ---------------------------------------------------------------------------
-
-
-class OllamaBudgetExceeded(RuntimeError):
-    """Raised when the Ollama per-cycle turn or wall-clock budget is exceeded.
-
-    Subclasses ``RuntimeError`` to match the existing safety-abort hierarchy
-    (e.g. :class:`~code_generator.runner.types.OverageAbort`).
-    """
-
-
-# ---------------------------------------------------------------------------
-# Tracker
-# ---------------------------------------------------------------------------
-
-
-class OllamaBudgetTracker:
-    """Cheap per-cycle budget checker; a no-op on the Anthropic Max path."""
-
-    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
-
-    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:
-        """Raise :class:`OllamaBudgetExceeded` when either budget is breached."""
-        if not self._active:
-            return
-        self._check_turn_budget(state, cycle)
-        self._check_wallclock_budget()
-
-    def _check_turn_budget(self, state: State, cycle: CycleState | None) -> None:
-        total = _sum_num_turns(state, cycle)
-        if total > OLLAMA_TURN_BUDGET:
-            raise OllamaBudgetExceeded(
-                f"Ollama turn-count budget exceeded: {total} > {OLLAMA_TURN_BUDGET}. "
-                "Raise OLLAMA_TURN_BUDGET in code_generator.orchestrator.ollama_budget "
-                "if real workloads need a higher cap."
-            )
-
-    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 in "
-                "code_generator.orchestrator.ollama_budget if real workloads "
-                "need a higher cap."
-            )
-
-
-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())