claude-code-generator 0.5.7__tar.gz → 0.5.9__tar.gz

{claude_code_generator-0.5.7/src/claude_code_generator.egg-info → claude_code_generator-0.5.9}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.5.7"
+version = "0.5.9"
 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" }
@@ -96,4 +96,4 @@ asyncio_mode = "auto"
 
 [tool.pyright]
 # Test mocks intentionally use unused parameters to match the production interface signature.
-reportUnusedParameter = "none"
+reportUnusedParameter = false

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.5.7
+Version: 0.5.9
 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.5.7 → claude_code_generator-0.5.9}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/code_generator/checklist.py
 src/code_generator/cli.py
 src/code_generator/effort.py
 src/code_generator/env.py
+src/code_generator/exceptions.py
 src/code_generator/git_ops.py
 src/code_generator/logging_setup.py
 src/code_generator/memory.py
@@ -151,6 +152,7 @@ tests/test_no_max_turns_in_call_sites.py
 tests/test_no_max_turns_literal.py
 tests/test_non_goals_grep_guard.py
 tests/test_ollama_budget.py
+tests/test_ollama_hardening.py
 tests/test_ollama_rate_limit.py
 tests/test_optimize.py
 tests/test_options.py

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/__init__.py

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

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/commands/_dispatch.py

@@ -310,9 +310,7 @@ async def _apply_delta_plan(
             "Phase 0 failed during delta planning; aborting to preserve cycle history."
         )
 
-    new_cycles = state_module.append_new_cycles(
-        st, raw_cycles, ollama_model=effective_model
-    )
+    new_cycles = state_module.append_new_cycles(st, raw_cycles, ollama_model=effective_model)
 
     if not new_cycles:
         logger.info("Delta planning: no new cycles detected.")

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/commands/generate.py

@@ -460,6 +460,9 @@ def generate_ollama_command(
         )
         raise typer.Exit(code=2)
 
+    # #268: advisory warning when the Ollama path carries a claude-* model tag.
+    env.warn_on_claude_model_for_ollama(effective_model)
+
     # (6) Persist the resolved model on existing cycles before dispatch so
     #     --continue resume stays consistent across sessions. New cycles
     #     created by phase 0/1 inherit the tag via the orchestrator thread

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/env.py

@@ -286,6 +286,34 @@ def assert_safe_environment() -> None:
     strip_dangerous_env()
 
 
+def warn_on_claude_model_for_ollama(model: str | None) -> None:
+    """Emit a WARNING when an Ollama-localhost env carries a ``claude-*`` model tag.
+
+    The Ollama codepath (#218) routes through a local daemon, so a
+    ``claude-opus-4-7`` / ``claude-sonnet-4-6`` / ``claude-haiku-*`` tag
+    almost always indicates a misconfiguration — the operator intended a
+    local model but typed an Anthropic model name.  The warning is purely
+    advisory; the upstream guarantee lives in the orchestrator's
+    ``_run_phases`` guard, which raises
+    :class:`~code_generator.exceptions.OllamaModelRequiredError` for the
+    same condition.
+
+    Args:
+        model: The resolved effective model tag, or ``None`` (no-op).
+    """
+    if model is not None and model.startswith("claude-"):
+        _logger.warning(
+            "Ollama daemon routing is active (ANTHROPIC_BASE_URL=%s) "
+            "but the model tag %r starts with 'claude-'. "
+            "This likely indicates a misconfiguration — did you mean "
+            "to use an Ollama model tag (e.g. 'qwen3-coder:480b:cloud')? "
+            "Use `code-generator generate ollama --model <tag>` for "
+            "single-model Ollama runs.",
+            OLLAMA_BASE_URL,
+            model,
+        )
+
+
 def assert_safe_environment_custom_model() -> None:
     """Strip Anthropic API creds but preserve routing for custom model endpoints.
 

claude_code_generator-0.5.9/src/code_generator/exceptions.py

@@ -0,0 +1,26 @@
+"""Shared exception classes for the code-generator pipeline.
+
+Single-responsibility: domain exception types only — no runner errors
+(those live in runner/types.py), no preflight errors (preflight.py).
+"""
+
+from __future__ import annotations
+
+
+class OllamaModelRequiredError(RuntimeError):
+    """Raised when the Ollama codepath has no resolvable model tag.
+
+    On the Ollama single-model path (#218), every phase requires a concrete
+    model tag (e.g. ``qwen3-coder:480b:cloud``).  This error fires when the
+    orchestrator detects that no model is available — either because
+    ``--model`` wasn't passed on a fresh run, or because the stored
+    ``CycleState.ollama_model`` is ``None`` on ``--continue``.
+
+    The ``fix_action`` string is a ready-to-paste remediation for the
+    operator; it is included in the error message automatically.
+    """
+
+    def __init__(self, reason: str, fix_action: str) -> None:
+        self.reason = reason
+        self.fix_action = fix_action
+        super().__init__(f"{reason} {fix_action}")

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/orchestrator/cycle_loop.py

@@ -14,11 +14,14 @@ Topological iteration:
 from __future__ import annotations
 
 import logging
+import os
 import shutil
 from typing import TYPE_CHECKING, Any, Literal
 
+from code_generator import env as _env
 from code_generator import gh, git_ops
 from code_generator import state as _state
+from code_generator.exceptions import OllamaModelRequiredError
 from code_generator.logging_setup import setup_phase_logger
 from code_generator.orchestrator import (
     phase1_plan,
@@ -171,6 +174,12 @@ def _resolve_effective_model(state: State, cycle: CycleState | None) -> str | No
     Priority: cycle.ollama_model (multi-cycle) > state.cycles[-1].ollama_model
     (single-mode fallback when ``cycle`` is not yet bound). The function never
     reads ``state.ollama_model`` because the field is cycle-level per #217.
+
+    Raises:
+        OllamaModelRequiredError: When the Ollama codepath is detected
+            (``ANTHROPIC_BASE_URL`` is localhost) and no model tag can be
+            resolved from state/cycle — this prevents a silent fallback
+            to an Anthropic model name.
     """
     if cycle is not None and cycle.ollama_model:
         return cycle.ollama_model
@@ -178,6 +187,21 @@ def _resolve_effective_model(state: State, cycle: CycleState | None) -> str | No
         last = state.cycles[-1]
         if isinstance(last, CycleState) and last.ollama_model:
             return last.ollama_model
+
+    if _env._is_localhost_base_url(os.environ.get("ANTHROPIC_BASE_URL")):  # noqa: SLF001
+        raise OllamaModelRequiredError(
+            reason=(
+                "Ollama daemon routing is active but no model tag is resolvable "
+                "from state.json. This happens when --continue is used on a "
+                "legacy state file that predates the ollama_model field, or "
+                "when --model was omitted on a fresh run."
+            ),
+            fix_action=(
+                "Re-run with --model <tag> to supply the model explicitly, e.g.: "
+                "code-generator generate ollama --model qwen3-coder:480b:cloud"
+            ),
+        )
+
     return None
 
 
@@ -231,6 +255,25 @@ async def _run_phases(
     if effective_model is None:
         effective_model = _resolve_effective_model(state, cycle)
 
+    # #268: belt-and-suspenders — when the Ollama codepath is active
+    # (effective_model is set) but the tag starts with "claude-", the operator
+    # almost certainly intended a local model.  Refuse before any phase runs
+    # so a mistyped tag never reaches the daemon (which would emit a cryptic
+    # "model may not exist").
+    if effective_model is not None and effective_model.startswith("claude-"):
+        raise OllamaModelRequiredError(
+            reason=(
+                f"Ollama single-model routing is active but the model tag "
+                f"{effective_model!r} starts with 'claude-'. "
+                "This likely indicates a misconfiguration — did you mean "
+                "to use an Ollama model tag?"
+            ),
+            fix_action=(
+                "Pass a valid Ollama model tag instead, e.g.: "
+                "code-generator generate ollama --model qwen3-coder:480b:cloud"
+            ),
+        )
+
     # #220: Ollama per-cycle budget tracker. ``effective_model is not None``
     # uniquely identifies the Ollama codepath inside the orchestrator, so we
     # key activation off it rather than threading an extra ``provider`` flag.

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/runner/sdk_runner.py

@@ -26,6 +26,7 @@ from code_generator.runner.message_parsing import (
     render_prompt,
     render_system_message,
 )
+from code_generator.runner.state_guard import protect_state_file
 from code_generator.runner.types import (
     ApiUpstreamError,
     MaxTurnsExceeded,
@@ -332,11 +333,12 @@ async def run(
     )
 
     t0 = time.monotonic()
-    async with ClaudeSDKClient(options=options) as client:
-        await client.query(prompt)
-        text, session_id, usage, compaction_events, clear_events = await _drain_messages(
-            client, logger, state_path
-        )
+    with protect_state_file(state_path):
+        async with ClaudeSDKClient(options=options) as client:
+            await client.query(prompt)
+            text, session_id, usage, compaction_events, clear_events = await _drain_messages(
+                client, logger, state_path
+            )
     wall_seconds = time.monotonic() - t0
 
     logger.info("SDK session complete.")
@@ -412,10 +414,11 @@ async def run_with_shared_client(
         prompt = pause_handler.consume(prompt, issue_number=consume_issue)
 
     t0 = time.monotonic()
-    await client.query(prompt)
-    text, session_id, usage, compaction_events, clear_events = await _drain_messages(
-        client, logger, state_path, pause_handler=pause_handler
-    )
+    with protect_state_file(state_path):
+        await client.query(prompt)
+        text, session_id, usage, compaction_events, clear_events = await _drain_messages(
+            client, logger, state_path, pause_handler=pause_handler
+        )
     wall_seconds = time.monotonic() - t0
 
     logger.info("SDK shared-client session complete.")

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/src/code_generator/runner/subprocess_runner.py

@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING, Any
 
 from code_generator import env as _env
 from code_generator import state as _state
+from code_generator.runner.state_guard import protect_state_file
 
 # Import shared types from the canonical module (DIP: depend on abstraction).
 # Re-exported here so callers that previously imported from subprocess_runner
@@ -350,7 +351,8 @@ async def run(
             raise ApiUpstreamError(f"claude CLI exited with code {proc.returncode}")
 
     t0 = time.monotonic()
-    await asyncio.to_thread(_run_subprocess)
+    with protect_state_file(state_path):
+        await asyncio.to_thread(_run_subprocess)
     wall_seconds = time.monotonic() - t0
 
     return RunResult(

claude_code_generator-0.5.9/tests/test_ollama_hardening.py

@@ -0,0 +1,366 @@
+"""Tests for Ollama single-model hardening (issue #268).
+
+AC coverage:
+- OllamaModelRequiredError exists with fix-action message
+- _resolve_effective_model raises when on Ollama path and no model resolvable
+- _run_phases raises when effective_model starts with claude-
+- env warns when model tag starts with claude-* on localhost routing
+- Legacy state.json without ollama_model raises clear error on --continue
+- Anthropic Max path unchanged (effective_model=None)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from code_generator import state as _state
+from code_generator.exceptions import OllamaModelRequiredError
+from code_generator.runner.types import RunResult, TokenUsage
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+_OLLAMA_TAG = "qwen3-coder:480b:cloud"
+_CLAUDE_TAG = "claude-opus-4-7"
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_runner() -> MagicMock:
+    runner = MagicMock()
+    runner.run = AsyncMock(
+        return_value=RunResult(
+            text='{"mode":"single","cycles":[]}', session_id=None, usage=TokenUsage()
+        ),
+    )
+    return runner
+
+
+def _make_state(tmp_path: Path) -> tuple[_state.State, Path]:
+    st = _state.load_state(tmp_path / "missing.json")
+    cg = tmp_path / ".code-generator"
+    cg.mkdir(parents=True, exist_ok=True)
+    (cg / "memories").mkdir(exist_ok=True)
+    state_path = cg / "state.json"
+    _state.save_state(state_path, st)
+    return st, state_path
+
+
+def _make_cycle(ollama_model: str | None) -> _state.CycleState:
+    return _state.CycleState(
+        id=1,
+        name="c1",
+        milestone_number=1,
+        milestone_title="c1",
+        status="open",
+        phase=None,
+        issues=[],
+        commit_sha=None,
+        ollama_model=ollama_model,
+    )
+
+
+def _make_cycle_no_ollama_field() -> _state.CycleState:
+    """Create a CycleState that has no ollama_model attribute set."""
+    cycle = _state.CycleState(
+        id=1,
+        name="c1",
+        milestone_number=1,
+        milestone_title="c1",
+        status="open",
+        phase=None,
+        issues=[],
+        commit_sha=None,
+    )
+    # Simulate legacy state.json: remove the ollama_model attr
+    object.__setattr__(cycle, "ollama_model", None)
+    return cycle
+
+
+# ---------------------------------------------------------------------------
+# OllamaModelRequiredError
+# ---------------------------------------------------------------------------
+
+
+class TestOllamaModelRequiredError:
+    def test_exception_includes_reason_and_fix_action(self) -> None:
+        err = OllamaModelRequiredError("no model found", "pass --model <tag>")
+        assert "no model found" in str(err)
+        assert "pass --model <tag>" in str(err)
+
+    def test_exception_is_runtime_error(self) -> None:
+        err = OllamaModelRequiredError("x", "y")
+        assert isinstance(err, RuntimeError)
+
+    def test_reason_and_fix_action_accessible_as_attrs(self) -> None:
+        err = OllamaModelRequiredError("reason text", "fix text")
+        assert err.reason == "reason text"
+        assert err.fix_action == "fix text"
+
+
+# ---------------------------------------------------------------------------
+# _resolve_effective_model — raises when on Ollama path, no model resolvable
+# ---------------------------------------------------------------------------
+
+
+class TestResolveEffectiveModelRaisesOnMissingModel:
+    def test_raises_when_cycle_has_ollama_model_none_and_state_has_none(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://localhost:11434")
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(None)
+        state.cycles = [cycle]
+
+        with pytest.raises(OllamaModelRequiredError, match="no model tag"):
+            cycle_loop._resolve_effective_model(state, cycle)
+
+    def test_raises_when_cycle_is_none_and_state_cycles_have_none_model(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://localhost:11434")
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(None)
+        state.cycles = [cycle]
+
+        with pytest.raises(OllamaModelRequiredError, match="no model tag"):
+            cycle_loop._resolve_effective_model(state, None)
+
+    def test_returns_model_when_cycle_has_valid_tag(self, tmp_path: Path) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(_OLLAMA_TAG)
+        state.cycles = [cycle]
+
+        result = cycle_loop._resolve_effective_model(state, cycle)
+        assert result == _OLLAMA_TAG
+
+    def test_returns_none_on_anthropic_max_path(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """When no cycle has ollama_model set (None), returns None — Anthropic Max."""
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        state, _ = _make_state(tmp_path)
+        # No cycles in state → anthropic max path
+        result = cycle_loop._resolve_effective_model(state, None)
+        assert result is None
+
+    def test_returns_none_when_cycle_none_and_no_cycles_in_state(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        state, _ = _make_state(tmp_path)
+        state.cycles = []
+
+        result = cycle_loop._resolve_effective_model(state, None)
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# _run_phases — raises when effective_model starts with "claude-"
+# ---------------------------------------------------------------------------
+
+
+class TestRunPhasesRejectsClaudeModelOnOllamaPath:
+    @pytest.mark.asyncio
+    async def test_raises_when_effective_model_starts_with_claude_prefix(
+        self, tmp_path: Path
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(_CLAUDE_TAG)
+        state.cycles = [cycle]
+
+        with pytest.raises(OllamaModelRequiredError, match="claude-"):
+            await cycle_loop._run_phases(
+                state=state,
+                cycle=cycle,
+                project_dir=tmp_path,
+                runner_module=_make_runner(),
+                log_prefix="",
+                start_phase=1,
+                effective_model=_CLAUDE_TAG,
+            )
+
+    @pytest.mark.asyncio
+    async def test_does_not_raise_when_effective_model_is_none(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(None)
+        state.cycles = [cycle]
+
+        with (
+            patch.object(cycle_loop.phase1_plan, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase2_review, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase3_4_implement, "run", new=AsyncMock()),
+            patch.object(
+                cycle_loop.phase5_closure,
+                "run",
+                new=AsyncMock(return_value=MagicMock(new_issues=[])),
+            ),
+            patch.object(cycle_loop.phase6_test, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase7_commit, "run", new=AsyncMock()),
+            patch.object(cycle_loop, "reset_cycle_summary", lambda *a, **k: None),
+            patch.object(cycle_loop, "write_project_plan", lambda *a, **k: None),
+            patch.object(cycle_loop, "append_cycle_summaries", lambda *a, **k: None),
+            patch.object(cycle_loop, "populate_cycle_start_fields", lambda *a, **k: None),
+            patch.object(_state, "get_issues", lambda *a, **k: []),
+            patch.object(cycle_loop, "_capture_base_commit", lambda *a, **k: None),
+        ):
+            await cycle_loop._run_phases(
+                state=state,
+                cycle=cycle,
+                project_dir=tmp_path,
+                runner_module=_make_runner(),
+                log_prefix="",
+                start_phase=1,
+                effective_model=None,
+            )
+
+    @pytest.mark.asyncio
+    async def test_does_not_raise_when_effective_model_is_valid_ollama_tag(
+        self, tmp_path: Path
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(_OLLAMA_TAG)
+        state.cycles = [cycle]
+
+        with (
+            patch.object(cycle_loop.phase1_plan, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase2_review, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase3_4_implement, "run", new=AsyncMock()),
+            patch.object(
+                cycle_loop.phase5_closure,
+                "run",
+                new=AsyncMock(return_value=MagicMock(new_issues=[])),
+            ),
+            patch.object(cycle_loop.phase6_test, "run", new=AsyncMock()),
+            patch.object(cycle_loop.phase7_commit, "run", new=AsyncMock()),
+            patch.object(cycle_loop, "reset_cycle_summary", lambda *a, **k: None),
+            patch.object(cycle_loop, "write_project_plan", lambda *a, **k: None),
+            patch.object(cycle_loop, "append_cycle_summaries", lambda *a, **k: None),
+            patch.object(cycle_loop, "populate_cycle_start_fields", lambda *a, **k: None),
+            patch.object(_state, "get_issues", lambda *a, **k: []),
+            patch.object(cycle_loop, "_capture_base_commit", lambda *a, **k: None),
+        ):
+            await cycle_loop._run_phases(
+                state=state,
+                cycle=cycle,
+                project_dir=tmp_path,
+                runner_module=_make_runner(),
+                log_prefix="",
+                start_phase=1,
+                effective_model=_OLLAMA_TAG,
+            )
+
+
+# ---------------------------------------------------------------------------
+# env.warn_on_claude_model_for_ollama — WARNING for claude-* + localhost
+# ---------------------------------------------------------------------------
+
+
+class TestEnvWarnsOnClaudeModelWithLocalhost:
+    def test_warns_when_model_starts_with_claude_prefix(self, caplog) -> None:
+        from code_generator import env
+
+        with caplog.at_level(logging.WARNING, logger="code_generator.env"):
+            env.warn_on_claude_model_for_ollama("claude-opus-4-7")
+
+        assert any("claude-" in record.message for record in caplog.records), (
+            f"expected WARNING with 'claude-', got: {[r.message for r in caplog.records]}"
+        )
+
+    def test_does_not_warn_when_model_is_valid_ollama_tag(self, caplog) -> None:
+        from code_generator import env
+
+        with caplog.at_level(logging.WARNING, logger="code_generator.env"):
+            env.warn_on_claude_model_for_ollama("qwen3-coder:480b:cloud")
+
+        assert not caplog.records, (
+            f"expected no WARNING, got: {[r.message for r in caplog.records]}"
+        )
+
+    def test_does_not_raise_or_warn_when_model_is_none(self, caplog) -> None:
+        from code_generator import env
+
+        with caplog.at_level(logging.WARNING, logger="code_generator.env"):
+            env.warn_on_claude_model_for_ollama(None)
+
+        assert not caplog.records
+
+
+# ---------------------------------------------------------------------------
+# Legacy state.json without ollama_model → clear error on --continue
+# ---------------------------------------------------------------------------
+
+
+class TestLegacyStateWithoutOllamaModel:
+    @pytest.mark.asyncio
+    async def test_resolve_effective_model_raises_for_legacy_cycle_no_model(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://localhost:11434")
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle_no_ollama_field()
+        state.cycles = [cycle]
+
+        with pytest.raises(OllamaModelRequiredError, match="--continue"):
+            cycle_loop._resolve_effective_model(state, cycle)
+
+
+# ---------------------------------------------------------------------------
+# Anthropic Max path regression guard
+# ---------------------------------------------------------------------------
+
+
+class TestAnthropicMaxPathUnchanged:
+    def test_resolve_effective_model_returns_none_when_no_ollama_model_anywhere(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        state, _ = _make_state(tmp_path)
+        cycle = _make_cycle(None)
+        state.cycles = [cycle]
+
+        result = cycle_loop._resolve_effective_model(state, cycle)
+        assert result is None, f"Anthropic Max path broken: {result=}, expected None"
+
+    def test_resolve_effective_model_returns_none_empty_cycles_single_mode(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        state, _ = _make_state(tmp_path)
+        state.cycles = []
+
+        result = cycle_loop._resolve_effective_model(state, None)
+        assert result is None

{claude_code_generator-0.5.7 → claude_code_generator-0.5.9}/tests/test_phase1.py

@@ -1001,5 +1001,3 @@ class TestLoadSpecializedPrompt:
         result = phase1_plan._load_specialized_prompt(tmp_path, state, cycle)
 
         assert "Cycle scope here" in result
-
-