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

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

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

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

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

@@ -74,6 +74,38 @@ _PYTHON_CLI = AgentSelection(
 )
 
 
+# ---------------------------------------------------------------------------
+# Extra-skill detection
+# ---------------------------------------------------------------------------
+
+_EXTRA_SKILL_KEYWORDS: tuple[tuple[tuple[str, ...], tuple[str, ...]], ...] = (
+    (("supabase",), ("supabase", "supabase-postgres-best-practices")),
+    (
+        ("skfolio", "portfolio optim", "efficient frontier", "mean-variance", "risk parity"),
+        ("skfolio",),
+    ),
+    (("yfinance", "yahoo finance", "ohlcv", "stock data", "ticker data"), ("yfinance",)),
+    (("xlsx", ".xlsx", " excel", "spreadsheet"), ("xlsx",)),
+    (("docx", ".docx", "word document"), ("docx",)),
+)
+
+
+def _detect_extra_skills(block: str) -> tuple[str, ...]:
+    extras: list[str] = []
+    for keywords, skills in _EXTRA_SKILL_KEYWORDS:
+        if any(kw in block for kw in keywords):
+            extras.extend(skills)
+    return tuple(extras)
+
+
+def _merge(base: AgentSelection, extras: tuple[str, ...]) -> AgentSelection:
+    if not extras:
+        return base
+    existing = set(base.skills)
+    new_skills = base.skills + tuple(s for s in extras if s not in existing)
+    return AgentSelection(primary=base.primary, support=base.support, skills=new_skills)
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -131,18 +163,16 @@ def detect(requirements_path: Path) -> AgentSelection:
     has_fastapi = "fastapi" in block or "python api" in block
 
     if has_angular and has_fastapi:
-        return _ANGULAR_FASTAPI
-
-    if has_angular:
-        return _ANGULAR_ONLY
-
-    if has_fastapi:
-        return _FASTAPI
-
-    if "baml" in block or "llm function" in block:
-        return _BAML
-
-    if "typer" in block or "click" in block or "python cli" in block:
-        return _PYTHON_CLI
-
-    return _GENERIC_FALLBACK
+        base = _ANGULAR_FASTAPI
+    elif has_angular:
+        base = _ANGULAR_ONLY
+    elif has_fastapi:
+        base = _FASTAPI
+    elif "baml" in block or "llm function" in block:
+        base = _BAML
+    elif "typer" in block or "click" in block or "python cli" in block:
+        base = _PYTHON_CLI
+    else:
+        base = _GENERIC_FALLBACK
+
+    return _merge(base, _detect_extra_skills(block))

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

@@ -37,14 +37,51 @@ __all__ = ["dispatch_async", "dispatch_orchestrator"]
 
 _GRAPHIFY_TIMEOUT = int(os.environ.get("CODE_GENERATOR_GRAPHIFY_TIMEOUT", "600"))
 
+_GRAPHIFY_EXTRACT_CMD = ["graphify", "extract", "."]
+_GRAPHIFY_UPDATE_CMD = ["graphify", "update", "."]
 
 _SETUP_HINT = (
-    "graph-report: graphify-out/graph.json not found — run `/graphify .` once "
-    "inside Claude Code (or another graphify-compatible assistant) to seed the "
-    "knowledge graph. After that, code-generator will keep it fresh "
-    "automatically with `graphify update .`. Using fallback for now."
+    "graph-report: headless extraction via `graphify extract .` was attempted "
+    "automatically but failed — ensure graphify >= 0.7.3 is installed "
+    "(`pipx install graphifyy`) or run `/graphify .` once inside Claude Code "
+    "to seed the knowledge graph manually. Using fallback for now."
 )
 
+_GRAPHIFY_MIN_VERSION = (0, 7, 3)
+_GRAPHIFY_UPGRADE_HINT = (
+    "upgrade for headless seeding and v0.5.5 workaround removal: pip install -U graphifyy"
+)
+
+
+def _parse_version_line(stdout: str) -> str | None:
+    """Return 'X.Y.Z' from pip-show stdout, or None when the line is absent."""
+    for line in stdout.splitlines():
+        if line.startswith("Version:"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def _get_graphify_version_str() -> str | None:
+    """Probe installed graphifyy version via pip show; None on any failure."""
+    try:
+        result = subprocess.run(
+            ["pip", "show", "graphifyy"], capture_output=True, text=True, check=False
+        )
+        return _parse_version_line(result.stdout or "")
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def _probe_graphify_version(log: logging.Logger) -> None:
+    """Warn when graphify is below _GRAPHIFY_MIN_VERSION or undetectable."""
+    version_str = _get_graphify_version_str()
+    if version_str is None:
+        log.warning("graph-report: graphify version unknown — %s", _GRAPHIFY_UPGRADE_HINT)
+        return
+    version = tuple(int(p) for p in version_str.split(".") if p.isdigit())
+    if version < _GRAPHIFY_MIN_VERSION:
+        log.warning("graph-report: graphify %s detected — %s", version_str, _GRAPHIFY_UPGRADE_HINT)
+
 
 def _decode_stderr(stderr: bytes | str | None) -> str:
     """Decode subprocess stderr to a short single-line string for logging."""
@@ -55,42 +92,65 @@ def _decode_stderr(stderr: bytes | str | None) -> str:
     return text[:500]
 
 
-def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) -> None:
-    """Refresh the codebase graph via graphify and persist the report.
+def _extract_argv(ollama_model: str | None) -> list[str]:
+    """Build graphify extract argv, appending --backend ollama on the Ollama path."""
+    if ollama_model is not None:
+        return [*_GRAPHIFY_EXTRACT_CMD, "--backend", "ollama"]
+    return list(_GRAPHIFY_EXTRACT_CMD)
+
+
+def _run_graphify(
+    cmd: list[str],
+    project_dir: Path,
+    log: logging.Logger,
+    memories_dir: Path,
+) -> bool:
+    """Run a graphify subprocess. Write fallback and return False on any error."""
+    try:
+        log.info("graph-report: running %s", " ".join(cmd))
+        subprocess.run(  # noqa: S603
+            cmd,
+            cwd=project_dir,
+            timeout=_GRAPHIFY_TIMEOUT,
+            capture_output=True,
+            check=True,
+        )
+        return True
+    except subprocess.CalledProcessError as exc:
+        stderr = _decode_stderr(exc.stderr)
+        log.warning(
+            "graph-report: graphify exited %d; using fallback. stderr: %s",
+            exc.returncode,
+            stderr or "<empty>",
+        )
+    except subprocess.TimeoutExpired as exc:
+        log.warning("graph-report: graphify timed out after %ss; using fallback", exc.timeout)
+    except (FileNotFoundError, OSError) as exc:
+        log.warning("graph-report: could not invoke graphify (%s); using fallback", exc)
+    _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
+    return False
 
-    Graphify's shell CLI does **not** support a "build" subcommand — the full
-    LLM-driven build only happens through the ``/graphify`` slash-command
-    inside an AI assistant (Claude Code, Codex, Cursor, etc.).  The shell
-    binary only supports maintenance subcommands like ``update``, ``watch``,
-    ``query``.
+
+def _compute_and_persist_graph_report(
+    project_dir: Path, log: logging.Logger, *, ollama_model: str | None = None
+) -> None:
+    """Refresh the codebase graph via graphify and persist the report.
 
     Strategy:
 
-    1. If ``graphify-out/graph.json`` does **not** exist, the user has never
-       seeded the graph.  Log a one-time setup hint, write the fallback
-       sentinel, and return — do not call subprocess.  The user must run
-       ``/graphify .`` in their assistant once to seed it.
+    1. If ``graphify-out/graph.json`` does **not** exist, run
+       ``graphify extract .`` (headless LLM-driven seeding, requires >= 0.7.3).
+       On success, read ``GRAPH_REPORT.md`` and persist.  On failure, write the
+       fallback sentinel and emit :data:`_SETUP_HINT`.
 
-    2. If it exists, run ``graphify update .`` (cwd=project_dir).  This is
-       AST-only re-extraction, no LLM cost, fast on cached files.  It
-       refreshes ``graph.json`` and ``GRAPH_REPORT.md``.  Doc / paper /
-       image changes are *not* picked up — for those the user must run
-       ``/graphify .`` again in their assistant.
+    2. If it exists, run ``graphify update .`` (AST-only refresh, no LLM cost).
+       Refreshes ``graph.json`` and ``GRAPH_REPORT.md``.
 
     Falls back to :data:`code_generator.memory.REPOMAP_FALLBACK` on any
     failure (binary missing, timeout, non-zero exit, missing report file).
-    Stderr from graphify is captured and logged at WARN level on failure so
-    the user can diagnose without re-running by hand.
-
-    Auth: graphify inherits the parent process env. ``graphify update`` is
-    AST-only and makes no LLM calls, so OAuth context is irrelevant on this
-    codepath — but we still don't strip ``ANTHROPIC_*`` because the startup
-    ``env.assert_safe_environment()`` check (CLAUDE.md non-negotiable #1)
-    already guarantees those vars are absent on the Anthropic Max path.
 
     Args:
-        project_dir: Project root directory (graphify writes ``graphify-out/``
-            into this directory).
+        project_dir: Project root directory.
         log: Phase logger.
     """
     memories_dir = project_dir / ".code-generator" / "memories"
@@ -106,53 +166,14 @@ def _compute_and_persist_graph_report(project_dir: Path, log: logging.Logger) ->
         return
 
     if not graph_json.exists():
-        log.info(_SETUP_HINT)
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
-
-    cmd = ["graphify", "update", "."]
-    # GRAPHIFY_NO_TIPS=1 suppresses the tip-printer that has a NameError in
-    # graphify v0.5.5 (_os not in scope outside the install block).
-    os.environ.setdefault("GRAPHIFY_NO_TIPS", "1")
-    try:
-        log.info("graph-report: refreshing (cmd=%s)", " ".join(cmd))
-        subprocess.run(  # noqa: S603
-            cmd,
-            cwd=project_dir,
-            timeout=_GRAPHIFY_TIMEOUT,
-            capture_output=True,
-            check=True,
-        )
-    except subprocess.CalledProcessError as exc:
-        stderr = _decode_stderr(exc.stderr)
-        # graphify v0.5.5 has a NameError in its tip-printer (_os not in scope)
-        # that fires after a successful update — treat it as success so the
-        # real GRAPH_REPORT.md is used instead of the fallback sentinel.
-        if "NameError: name '_os' is not defined" in (stderr or ""):
-            log.info(
-                "graph-report: graphify tip-printer bug (v0.5.5) — graph updated; ignoring exit 1"
-            )
-        else:
-            log.warning(
-                "graph-report: graphify exited %d; using fallback. stderr: %s",
-                exc.returncode,
-                stderr or "<empty>",
-            )
-            _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
+        log.info("graph-report: graph.json absent — attempting headless extraction")
+        if not _run_graphify(_extract_argv(ollama_model), project_dir, log, memories_dir):
+            log.info(_SETUP_HINT)
+            return
+    else:
+        _probe_graphify_version(log)
+        if not _run_graphify(_GRAPHIFY_UPDATE_CMD, project_dir, log, memories_dir):
             return
-    except subprocess.TimeoutExpired as exc:
-        log.warning(
-            "graph-report: graphify timed out after %ss; using fallback",
-            exc.timeout,
-        )
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
-    except (FileNotFoundError, OSError) as exc:
-        # `FileNotFoundError` here means the `graphify` binary disappeared
-        # between `shutil.which` and `subprocess.run`. Extremely unlikely.
-        log.warning("graph-report: could not invoke graphify (%s); using fallback", exc)
-        _memory.write_memory_file(memories_dir, "cycle-repo-map.md", _memory.REPOMAP_FALLBACK)
-        return
 
     try:
         content = report_path.read_text(encoding="utf-8")
@@ -289,7 +310,9 @@ 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)
+    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.")
@@ -344,7 +367,7 @@ async def dispatch_async(
     # Build the codebase graph once at the top of dispatch so Phase 0
     # (complexity analysis) sees a fresh report alongside Phases 1 and 2.
     graph_logger = setup_phase_logger("graph-report", project_dir)
-    _compute_and_persist_graph_report(project_dir, graph_logger)
+    _compute_and_persist_graph_report(project_dir, graph_logger, ollama_model=ollama_model)
 
     # Phase 0: determine mode when not already known.
     if mode == "auto":

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

@@ -147,6 +147,20 @@ def _persist_repo_info(
 @generate_app.callback(invoke_without_command=True)
 def generate_command(
     ctx: typer.Context,
+    model: Annotated[
+        str | None,
+        typer.Option(
+            "--model",
+            help=(
+                "Model tag to use for ALL phases (single-model routing). "
+                "When set, overrides the per-phase Opus/Sonnet/Haiku defaults "
+                "and routes every phase through the operator's configured endpoint. "
+                "Preserves existing ANTHROPIC_AUTH_TOKEN + ANTHROPIC_BASE_URL from "
+                "the parent environment."
+            ),
+            show_default=False,
+        ),
+    ] = None,
     dry_run: Annotated[
         bool,
         typer.Option("--dry-run/--no-dry-run", help="Print what would happen without doing it."),
@@ -192,12 +206,21 @@ def generate_command(
         ),
     ] = None,
 ) -> None:
-    """Run the full code-generation pipeline (default: Anthropic Max)."""
+    """Run the full code-generation pipeline (default: Anthropic Max).
+
+    Pass --model to route all phases through a custom endpoint (e.g. a local
+    Ollama daemon or a cloud proxy) instead of Anthropic Max. When --model is
+    set, the existing ANTHROPIC_AUTH_TOKEN and ANTHROPIC_BASE_URL from the
+    parent environment are preserved.
+    """
     # A subcommand like `generate ollama` has its own body; skip the default flow.
     if ctx.invoked_subcommand is not None:
         return
 
-    env.assert_safe_environment()
+    if model is not None:
+        env.assert_safe_environment_custom_model()
+    else:
+        env.assert_safe_environment()
     env.assert_single_workspace()
 
     if phase is not None and continue_:
@@ -235,6 +258,11 @@ def generate_command(
     # Persist the fresh RepoInfo atomically; warns when it differs from stored value.
     _persist_repo_info(st, repo_info, state_path)
 
+    # When --model is set, stamp the tag on existing cycles so --continue
+    # resolves the correct model without the operator re-typing --model.
+    if model is not None:
+        _stamp_model_on_existing_cycles(st, model, state_path)
+
     # Rate-limit pause guard: inform user and exit cleanly.
     if _check_paused(st):
         raise typer.Exit(code=0)
@@ -262,6 +290,7 @@ def generate_command(
             session_mode=effective_session_mode,
             session_mode_explicit=session_mode_explicit,
             max_turns=max_turns,
+            ollama_model=model,
         )
     except typer.Exit:
         raise

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

@@ -286,6 +286,33 @@ def assert_safe_environment() -> None:
     strip_dangerous_env()
 
 
+def assert_safe_environment_custom_model() -> None:
+    """Strip Anthropic API creds but preserve routing for custom model endpoints.
+
+    When ``--model`` is passed to the default ``generate`` command (not the
+    ``ollama`` subcommand), the operator's existing ``ANTHROPIC_AUTH_TOKEN``
+    and ``ANTHROPIC_BASE_URL`` are preserved so the custom endpoint routing
+    survives. Only real Anthropic credit keys are stripped.
+    """
+    offenders = [var for var in DANGEROUS_VARS if var in os.environ]
+    if offenders:
+        listed = ", ".join(offenders)
+        print(
+            f"Using custom model (preserving routing, ignoring {listed} for this process).",
+            file=sys.stderr,
+        )
+    _strip_dangerous_env_custom()
+
+
+def _strip_dangerous_env_custom() -> None:
+    """Strip DANGEROUS_VARS except ANTHROPIC_AUTH_TOKEN (preserve custom routing)."""
+    protected = {"ANTHROPIC_AUTH_TOKEN"}
+    for var in DANGEROUS_VARS:
+        if var in protected:
+            continue
+        os.environ.pop(var, None)
+
+
 def assert_safe_environment_ollama() -> None:
     """Strip Anthropic env vars and install the scoped Ollama routing in place.
 

{claude_code_generator-0.5.6 → claude_code_generator-0.5.7}/src/code_generator/orchestrator/phase1_plan.py

@@ -38,19 +38,6 @@ class Phase1NoIssuesError(RuntimeError):
     """Phase 1 completed but created zero GitHub issues — abort the pipeline."""
 
 
-class MissingSpecializedPromptError(RuntimeError):
-    """Multi-cycle: per-cycle specialized prompt file is missing or hash unset.
-
-    Raised from :func:`_load_specialized_prompt` when ``state.mode == "multi-cycle"``
-    and either ``state.requirements_hash`` is ``None`` or the expected
-    ``cycle_<id>.md`` file does not exist under
-    ``.code-generator/cycles_prompts/<requirements_hash>/``.
-
-    Operator fix: re-run ``code-generator generate --phase 0 --cycle <K>`` to
-    regenerate the per-cycle briefings.
-    """
-
-
 def _deduplicate_by_title(issues: list[dict[str, Any]]) -> list[dict[str, Any]]:  # type: ignore[type-arg]
     """Return only the lowest-numbered issue per case-insensitive stripped title.
 
@@ -174,29 +161,42 @@ def _accumulate_usage(
     )
 
 
-def _multi_cycle_briefing(project_dir: Path, state: State, cycle: CycleState) -> str:
-    """Load the per-cycle briefing or raise if the hash/file is missing."""
+def _multi_cycle_briefing(
+    project_dir: Path,
+    state: State,
+    cycle: CycleState,
+    logger: logging.Logger | None = None,
+) -> str:
+    """Load the per-cycle briefing or fall back to raw requirements.
+
+    When the cycle prompt file is missing (e.g. because
+    :func:`~code_generator.orchestrator.cycle_prompts.generate_cycle_prompts`
+    failed during Phase 0 — common with non-Anthropic models that struggle with
+    the specializer JSON format), a WARNING is emitted and the raw
+    ``requirements.md`` is returned as a safe fallback. The operator can re-run
+    ``--phase 0 --cycle N`` later to regenerate the specialized briefings.
+    """
     if state.requirements_hash is None:
-        raise MissingSpecializedPromptError(
-            "multi-cycle Phase 1 requires state.requirements_hash to be set; "
-            f"got None for cycle {cycle.id}. Re-run "
-            f"`code-generator generate --phase 0 --cycle {cycle.id}` to regenerate."
-        )
+        if logger:
+            logger.warning(
+                "cycle-prompts: requirements_hash is None for cycle %d — "
+                "falling back to raw requirements.",
+                cycle.id,
+            )
+        return _single_cycle_fallback(project_dir)
     try:
         return _cycle_prompts.load_cycle_prompt(project_dir, state.requirements_hash, cycle.id)
-    except FileNotFoundError as exc:
-        expected = (
-            project_dir
-            / ".code-generator"
-            / "cycles_prompts"
-            / state.requirements_hash
-            / f"cycle_{cycle.id}.md"
-        )
-        raise MissingSpecializedPromptError(
-            f"multi-cycle Phase 1 expected specialized briefing at {expected} "
-            f"but it is missing. Re-run "
-            f"`code-generator generate --phase 0 --cycle {cycle.id}` to regenerate."
-        ) from exc
+    except FileNotFoundError:
+        if logger:
+            logger.warning(
+                "cycle-prompts: specialized briefing missing for cycle %d (hash=%s) — "
+                "falling back to raw requirements. Re-run "
+                "`code-generator generate --phase 0 --cycle %d` to regenerate.",
+                cycle.id,
+                state.requirements_hash,
+                cycle.id,
+            )
+        return _single_cycle_fallback(project_dir)
 
 
 def _single_cycle_fallback(project_dir: Path) -> str:
@@ -213,21 +213,21 @@ def _load_specialized_prompt(
     project_dir: Path,
     state: State,
     cycle: CycleState | None,
+    logger: logging.Logger | None = None,
 ) -> str:
     """Return the cycle-specialized briefing or the single-cycle fallback.
 
-    Multi-cycle mode (``state.mode == "multi-cycle"`` with ``cycle is not None``)
-    must read the verbatim per-cycle briefing from
-    ``.code-generator/cycles_prompts/<requirements_hash>/cycle_<id>.md``. A
-    missing hash or missing file raises :class:`MissingSpecializedPromptError`
-    so the operator can repair the cycles_prompts/ folder before tokens burn
-    on a malformed Phase 1 prompt (issue #232).
+    Multi-cycle mode reads the verbatim per-cycle briefing from
+    ``.code-generator/cycles_prompts/<requirements_hash>/cycle_<id>.md``.
+    When the file is missing (common when the cycle-prompts specializer call
+    fails with non-Anthropic models), falls back to raw ``requirements.md``
+    with a warning instead of crashing the pipeline.
 
     Single-cycle mode (``cycle is None``) keeps the historic raw-requirements
     fallback because there is no per-cycle briefing to load.
     """
     if state.mode == "multi-cycle" and cycle is not None:
-        return _multi_cycle_briefing(project_dir, state, cycle)
+        return _multi_cycle_briefing(project_dir, state, cycle, logger=logger)
     return _single_cycle_fallback(project_dir)
 
 
@@ -296,7 +296,9 @@ async def run(
         repo_map = _memory.read_cycle_repomap(memories_dir)
         prompt = load_prompt(
             "prompt-phase-1-planning.md",
-            CYCLE_SPECIALIZED_PROMPT=_load_specialized_prompt(project_dir, state, cycle),
+            CYCLE_SPECIALIZED_PROMPT=_load_specialized_prompt(
+                project_dir, state, cycle, logger=logger
+            ),
             CYCLE_SCOPE=(
                 cycle.scope
                 if cycle is not None

{claude_code_generator-0.5.6 → claude_code_generator-0.5.7}/src/code_generator/orchestrator/phase5_closure.py

@@ -26,7 +26,6 @@ from code_generator.runner.cache_breakpoints import resolve_active_ttl
 from code_generator.runner.mcp import build_mcp_servers, mcp_tool_wildcards
 from code_generator.runner.options import make_agent_options, max_turns_kwargs
 from code_generator.runner.phase_telemetry import accumulate_phase_telemetry
-from code_generator.runner.sdk_runner import run_with_shared_client
 from code_generator.runner.types import TokenUsage
 
 if TYPE_CHECKING:
@@ -183,27 +182,24 @@ async def _run_closure(
     options: Any,
     *,
     runner_module: RunnerProtocol,
-    shared_client: Any | None,
     state_path: Path,
     logger: logging.Logger,
 ) -> Any:
-    """Dispatch the closure session to shared-client or fresh-runner path.
+    """Run the closure session via one-shot subprocess.
+
+    Phase 5 always uses the fresh runner so the reviewer sees only artefacts,
+    not the Phase 3/4 implementation conversation.
 
     Args:
         prompt: The prompt text to send.
         options: Agent options (model, tools, etc.).
-        runner_module: Fresh-mode runner (used only when shared_client is None).
-        shared_client: Open ClaudeSDKClient for shared-session mode, or None.
+        runner_module: One-shot subprocess runner.
         state_path: Path to state.json for rate-limit persistence.
         logger: Phase logger.
 
     Returns:
-        RunResult from whichever path was taken.
+        RunResult from rate_limit.main_loop.
     """
-    if shared_client is not None:
-        return await run_with_shared_client(
-            shared_client, prompt, options, logger=logger, state_path=state_path
-        )
     return await rate_limit.main_loop(
         runner_module, prompt, options, state_path=state_path, logger=logger
     )
@@ -273,24 +269,24 @@ async def run(
     *,
     runner_module: RunnerProtocol,
     logger: logging.Logger | None = None,
-    shared_client: Any = None,
+    shared_client: Any = None,  # accepted for call-site compat; Phase 5 uses one-shot subprocess
     max_turns: int | None = None,
     effective_model: str | None = None,
 ) -> FixResult:
     """Execute phase 5: overall review and closure.
 
+    Phase 5 always runs in one-shot subprocess mode so the reviewer sees only
+    the final artefacts, not the Phase 3/4 implementation conversation.
+
     Args:
         state: Root state object (mutated in place).
         cycle: Active cycle (multi-cycle) or ``None`` (single mode).
         project_dir: Project root directory.
         runner_module: Runner module from ``get_runner()``.
         logger: Optional phase logger.
-        shared_client: Open ``ClaudeSDKClient`` injected by the orchestrator
-            in shared-session mode; ``None`` in fresh mode.  When set, the
-            closure session is dispatched via ``run_with_shared_client()`` so
-            the Phase 2 + Phase 3/4 cache prefix is preserved.  No
-            ``soft_reset_context()`` call is made — Phase 5 runs once per
-            cycle (not per issue).
+        shared_client: Accepted but ignored — Phase 5 deliberately runs one-shot.
+            The shared client lifecycle is managed by ``managed_shared_client``
+            in ``cycle_loop.py`` and remains open after Phase 5 returns.
 
     Returns:
         :class:`FixResult` listing any new fix issues discovered after the
@@ -355,7 +351,6 @@ async def run(
         prompt,
         options,
         runner_module=runner_module,
-        shared_client=shared_client,
         state_path=state_path,
         logger=logger,
     )