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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.11
+Version: 0.4.13
 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.11 → claude_code_generator-0.4.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.11"
+version = "0.4.13"
 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.11 → claude_code_generator-0.4.13/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.11
+Version: 0.4.13
 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.11 → claude_code_generator-0.4.13}/src/code_generator/__init__.py

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

{claude_code_generator-0.4.11 → claude_code_generator-0.4.13}/src/code_generator/orchestrator/ollama_budget.py

@@ -1,10 +1,8 @@
 """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:
+The pre-0.4.11 design aborted cycles on two arbitrary counters — 200 turns
+and 1 h wall-clock. That's the wrong layer: fault-detection already lives
+in two places that trigger on real malfunctions, not on counters:
 
   * :class:`~code_generator.runner.retry.CircuitBreaker` — trips after ``N``
     consecutive failures on a single phase call. Already wrapped around
@@ -13,29 +11,27 @@ arbitrary counter:
   * :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:
+Starting with 0.4.13 both thresholds are **soft warnings** — the module
+never aborts the pipeline. Weak open models are slow AND chatty; letting
+them run is the right call. The operator can always Ctrl-C a runaway.
 
-  * 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).
+  * ``OLLAMA_SOFT_TURN_WARN``  (int, positive; default 500). Emitted once
+    per cycle when cumulative ``num_turns`` crosses the threshold.
+  * ``OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS``  (int, positive; default 14400).
+    Emitted once per cycle when elapsed wall-clock crosses the threshold.
 
-Both thresholds are env-overridable:
+Backwards-compatible shims: the legacy env names ``OLLAMA_TURN_BUDGET`` and
+``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` remain honoured and map onto the new
+soft-warn thresholds. Scripts that previously relied on the abort now see
+a WARNING instead; the 0.4.11 changelog entry called this out for the turn
+budget, and 0.4.13 extends the same semantics to wall-clock.
 
-  * ``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.
+:class:`OllamaBudgetExceeded` is retained only as a concrete exception
+type for backwards compatibility with callers that ``except`` it — it is
+no longer raised by this module.
 
 Nothing is persisted in ``state.json`` — the tracker is per-run and
-discarded on abort or clean completion.
+discarded on clean completion.
 """
 
 from __future__ import annotations
@@ -57,7 +53,7 @@ _logger = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 
 _DEFAULT_SOFT_TURN_WARN = 500
-_DEFAULT_WALLCLOCK_BUDGET_SECONDS = 14400  # 4 h
+_DEFAULT_WALLCLOCK_SOFT_WARN_SECONDS = 14400  # 4 h
 
 
 def _read_int_env(name: str, default: int) -> int:
@@ -100,17 +96,31 @@ aborts.
 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.
+def _resolve_wallclock_soft_warn() -> int:
+    """Honour legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` env var for backwards compat."""
+    legacy = _read_int_env("OLLAMA_WALLCLOCK_BUDGET_SECONDS", 0)
+    if legacy:
+        return legacy
+    return _read_int_env(
+        "OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS", _DEFAULT_WALLCLOCK_SOFT_WARN_SECONDS
+    )
+
+
+OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS = _resolve_wallclock_soft_warn()
+"""Soft warning threshold on per-cycle wall-clock elapsed (seconds).
 
-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.
+Defaults to 14400 (4 h). Override via ``OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS``
+(new name) or the legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` (preserved for
+backwards compatibility). The value is **non-blocking**: the pipeline only
+logs a WARNING once per cycle when elapsed 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_WALLCLOCK_BUDGET_SECONDS = OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS
+"""Backwards-compatible alias for :data:`OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS`."""
+
 
 # ---------------------------------------------------------------------------
 # Exception
@@ -118,11 +128,12 @@ stuck daemon or a pathological loop the per-phase
 
 
 class OllamaBudgetExceeded(RuntimeError):
-    """Raised when the Ollama per-cycle wall-clock backstop is exceeded.
+    """Retained only for backwards compatibility with ``except`` clauses.
 
-    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`.
+    As of 0.4.13 this module never raises ``OllamaBudgetExceeded``. Both the
+    turn counter and the wall-clock are non-blocking soft WARNINGs. 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`).
@@ -137,9 +148,8 @@ class OllamaBudgetExceeded(RuntimeError):
 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
+    Emits at most one WARNING per threshold (turn count, wall-clock). **Never
+    aborts**. Real failures are the responsibility of
     :class:`~code_generator.runner.retry.CircuitBreaker` and the rate-limit
     handlers in :mod:`code_generator.runner.rate_limit`.
     """
@@ -162,6 +172,7 @@ class OllamaBudgetTracker:
         self._clock = clock or time.monotonic
         self._start_time: float | None = None
         self._turn_warning_emitted = False
+        self._wallclock_warning_emitted = False
 
     def start(self) -> None:
         """Record the cycle start time. Idempotent; only the first call matters."""
@@ -169,11 +180,11 @@ class OllamaBudgetTracker:
             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."""
+        """Warn on either threshold; never raise."""
         if not self._active:
             return
         self._check_turn_soft_warn(state, cycle)
-        self._check_wallclock_budget()
+        self._check_wallclock_soft_warn()
 
     def _check_turn_soft_warn(self, state: State, cycle: CycleState | None) -> None:
         """Emit one WARNING the first time the cycle crosses the soft threshold.
@@ -196,17 +207,29 @@ class OllamaBudgetTracker:
             )
             self._turn_warning_emitted = True
 
-    def _check_wallclock_budget(self) -> None:
-        if self._start_time is None:
+    def _check_wallclock_soft_warn(self) -> None:
+        """Emit one WARNING the first time the cycle crosses the wall-clock threshold.
+
+        Never raises. As of 0.4.13 the wall-clock ceiling is advisory: a
+        genuinely stuck daemon will be caught by the per-phase
+        CircuitBreaker or by the operator's Ctrl-C; aborting a live session
+        on a counter wastes hours of work.
+        """
+        if self._wallclock_warning_emitted or 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."
+        if elapsed > OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS:
+            _logger.warning(
+                "Ollama cycle has been running for %.0fs (soft threshold: "
+                "%ds). Letting it run — real stalls are caught by the "
+                "per-phase CircuitBreaker in runner/retry.py. Raise the "
+                "threshold via OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS or the "
+                "legacy OLLAMA_WALLCLOCK_BUDGET_SECONDS env var to silence "
+                "this warning. Use Ctrl-C to stop a truly runaway cycle.",
+                elapsed,
+                OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS,
             )
+            self._wallclock_warning_emitted = True
 
 
 def _sum_num_turns(state: State, cycle: CycleState | None) -> int:

{claude_code_generator-0.4.11 → claude_code_generator-0.4.13}/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.11 → claude_code_generator-0.4.13}/src/code_generator/prompts/prompt-phase-6-test.md

@@ -18,16 +18,22 @@ You are a senior engineer specialized in testing. Your task is to run the projec
    - `Cargo.toml` → Rust/cargo test
    - `go.mod` → Go test
 
-2. **Run the full test suite:**
+2. **Run the full test suite with concise output** (see Constraints):
    ```bash
-   # Adapt to the detected framework
-   pytest -xvs                    # Python
-   npm test -- --run              # Vitest
+   # Adapt to the detected framework.
+   pytest -q --tb=line            # Python — quiet, one-line tracebacks
+   npm test -- --run --reporter=default  # Vitest
    npm test                       # Jest/Angular
-   cargo test --all               # Rust
-   go test ./...                  # Go
+   cargo test --all --quiet       # Rust
+   go test ./... 2>&1 | tail -200 # Go — only the last 200 lines
    ```
 
+   **Do not use `-v`, `-vv`, `-s`, or any other verbose/stream flag.** A
+   tool result returned to the model cannot exceed roughly 1 MB — verbose
+   pytest output on a medium-sized project blows past that limit and
+   crashes the SDK stream reader mid-cycle. Start quiet; escalate only the
+   individual failing test with `-v` after you have the list of failures.
+
 3. **If all tests pass on the first attempt:**
    - Also run any available linters/type checkers (`mypy`, `ruff`, `eslint`, `tsc --noEmit`)
    - Collect test coverage if the framework supports it
@@ -98,6 +104,7 @@ You are a senior engineer specialized in testing. Your task is to run the projec
 - **Do not ask the user for confirmation**: act autonomously in YOLO mode.
 - **If you find flakiness** (a test that passes/fails non-deterministically), do not ignore it: document the flaky behavior in the bug issue.
 - **Environment variables already available globally**: `GITHUB_TOKEN`, `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GOOGLE_API_KEY`, `OLLAMA_API_KEY`, `OLLAMA_BASE_URL`. If a test fails because "an API key is missing" among these, the cause is **not** the missing key — check the variable name, the `.env` loading, or an explicit override in the test. Do not add dummy keys as a fix. For tests that make real calls and are slow/expensive, use mocking/VCR cassettes instead of disabling them.
+- **Tool-result size ceiling.** Bash tool-results larger than ~1 MB crash the SDK stream reader. Always prefer `-q`/`--tb=line`/`--quiet` over `-v`/`-vv`/`-s`. If a command genuinely produces more than 1 MB of output, tee it to a file (`cmd > /tmp/out.log 2>&1 || true`) and then `Read` or `Grep` the file — never let the full output flow back through a single tool result.
 
 ---
 

{claude_code_generator-0.4.11 → claude_code_generator-0.4.13}/tests/test_ollama_budget.py

@@ -1,30 +1,35 @@
-"""Tests for the Ollama per-cycle adaptive safety backstop (issue #220, 0.4.11).
+"""Tests for the Ollama per-cycle adaptive safety backstop (0.4.13).
 
-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).
+Both the turn counter and the wall-clock are **non-blocking soft warnings**
+— the pipeline is never aborted on either threshold alone. Real per-call
+failures are the job of :class:`~code_generator.runner.retry.CircuitBreaker`
+and the rate-limit handlers.
 
-Backwards compatibility: ``OLLAMA_TURN_BUDGET`` is preserved as an alias
-for :data:`OLLAMA_SOFT_TURN_WARN` so existing scripts keep importing.
+Backwards compatibility: ``OLLAMA_TURN_BUDGET`` and
+``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` are preserved as aliases for
+:data:`OLLAMA_SOFT_TURN_WARN` and :data:`OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS`
+respectively, so existing scripts keep importing.
 """
 
 from __future__ import annotations
 
 import logging
-
-import pytest
+from typing import TYPE_CHECKING
 
 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,
+    OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS,
     OllamaBudgetExceeded,
     OllamaBudgetTracker,
 )
 from code_generator.runner.types import TokenUsage
 
+if TYPE_CHECKING:
+    import pytest
+
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
@@ -38,8 +43,12 @@ class TestThresholdConstants:
         """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
+    def test_wallclock_soft_warn_default_is_4_hours(self) -> None:
+        assert OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS == 14400
+
+    def test_wallclock_budget_alias_matches_soft_warn(self) -> None:
+        """Legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` must alias the soft-warn constant."""
+        assert OLLAMA_WALLCLOCK_BUDGET_SECONDS == OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS
 
 
 # ---------------------------------------------------------------------------
@@ -149,9 +158,9 @@ class TestTurnSoftWarning:
 # ---------------------------------------------------------------------------
 
 
-class TestWallclockBudget:
-    def test_under_budget_does_not_raise(self) -> None:
-        """Elapsed < budget → no raise."""
+class TestWallclockSoftWarning:
+    def test_under_threshold_does_not_warn(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Elapsed < threshold → no WARNING emitted, no raise."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         now = 1_000_000.0
         tracker = OllamaBudgetTracker(
@@ -159,12 +168,18 @@ class TestWallclockBudget:
             clock=lambda: now,
         )
         tracker.start()
-        now += OLLAMA_WALLCLOCK_BUDGET_SECONDS - 10
+        now += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS - 10
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert wallclock_warnings == []
 
-    def test_over_budget_raises_with_exact_message(self) -> None:
-        """Elapsed > budget → OllamaBudgetExceeded naming wall-clock."""
+    def test_over_threshold_warns_without_raising(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Crossing the threshold logs a WARNING; the pipeline continues."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         t = [1_000_000.0]
 
@@ -173,14 +188,32 @@ class TestWallclockBudget:
 
         tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=_clock)
         tracker.start()
-        t[0] += OLLAMA_WALLCLOCK_BUDGET_SECONDS + 1
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 1
+
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)  # must not raise
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert len(wallclock_warnings) == 1
+        assert str(OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS) in wallclock_warnings[0].message
+
+    def test_warning_is_emitted_only_once_per_cycle(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Subsequent checks after the first wall-clock warning must stay silent."""
+        st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
+        t = [1_000_000.0]
+        tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=lambda: t[0])
+        tracker.start()
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 1
 
-        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 "wall" in msg.lower() or "clock" in msg.lower()
-        assert str(OLLAMA_WALLCLOCK_BUDGET_SECONDS) in msg
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert len(wallclock_warnings) == 1
 
     def test_start_is_required_before_check(self) -> None:
         """check() without start() returns immediately on wall-clock (None start)."""
@@ -190,7 +223,7 @@ class TestWallclockBudget:
         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."""
+        """Neither counter should raise on its own — both are soft warnings now."""
         st, cycle = _make_state_with_usage(
             {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN * 100}
         )
@@ -198,6 +231,16 @@ class TestWallclockBudget:
 
         tracker.check(st, cycle)  # must not raise
 
+    def test_extreme_wallclock_does_not_raise(self) -> None:
+        """Wall-clock far past threshold must not raise either (0.4.13)."""
+        st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
+        t = [1_000_000.0]
+        tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=lambda: t[0])
+        tracker.start()
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS * 10  # 40 h
+
+        tracker.check(st, cycle)  # must not raise
+
 
 # ---------------------------------------------------------------------------
 # Anthropic Max path — thresholds do not fire
@@ -218,15 +261,21 @@ class TestAnthropicMaxUntouched:
         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."""
+    def test_anthropic_max_mode_skips_wallclock_warning(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """provider_is_ollama=False → no WARNING, no raise."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         t = [1_000_000.0]
         tracker = OllamaBudgetTracker(provider_is_ollama=False, clock=lambda: t[0])
         tracker.start()
-        t[0] += OLLAMA_WALLCLOCK_BUDGET_SECONDS + 100
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 100
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert wallclock_warnings == []
 
 
 # ---------------------------------------------------------------------------