claude-code-generator 0.5.3__tar.gz → 0.5.5__tar.gz

{claude_code_generator-0.5.3/src/claude_code_generator.egg-info → claude_code_generator-0.5.5}/PKG-INFO

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

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

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

@@ -99,6 +99,7 @@ tests/test_bench_fixture.py
 tests/test_bench_regression.py
 tests/test_changelog.py
 tests/test_claude_md.py
+tests/test_cli_io_logging.py
 tests/test_client_lifecycle.py
 tests/test_comments.py
 tests/test_commit_message.py

{claude_code_generator-0.5.3 → claude_code_generator-0.5.5}/src/code_generator/__init__.py

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

claude_code_generator-0.5.5/src/code_generator/cli.py

@@ -0,0 +1,93 @@
+"""Entry-point CLI for code-generator.
+
+Exposes a Typer application with --version and subcommands:
+init, status, generate, review.
+
+At import time we reconfigure stdout/stderr for line-buffered output (the
+in-process equivalent of ``PYTHONUNBUFFERED=1``) so phase progress shows up
+in the terminal in real time even when the CLI is invoked through buffering
+wrappers like ``conda run``.  The default log level is DEBUG, overridable
+via the ``LOGLEVEL`` env var (set ``LOGLEVEL=INFO`` for the quieter behaviour
+that earlier 0.4.x releases shipped with).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+import code_generator
+from code_generator.commands.bench import bench_app
+from code_generator.commands.generate import generate_app
+from code_generator.commands.init import init_command
+from code_generator.commands.optimize import optimize_command
+from code_generator.commands.review import review_command
+from code_generator.commands.status import status_command
+
+
+def _configure_io_and_logging() -> None:
+    """Force line-buffered stdout/stderr and apply LOGLEVEL (default DEBUG).
+
+    Equivalent to running with ``PYTHONUNBUFFERED=1 LOGLEVEL=DEBUG`` from
+    the shell, but always-on so users don't have to remember the env vars.
+    Both can still be overridden externally — ``LOGLEVEL=INFO`` reverts to
+    the quieter default.
+
+    Idempotent: safe to call multiple times (the ``reconfigure`` call is a
+    no-op when line buffering is already on, and ``logging.basicConfig`` is
+    a no-op once root handlers exist).
+    """
+    # Line-buffered console I/O: each ``\n`` flushes immediately. The
+    # `contextlib.suppress` wrapper handles streams that are already buffered
+    # as needed or are non-seekable (e.g. piped to another process).
+    for stream in (sys.stdout, sys.stderr):
+        with contextlib.suppress(AttributeError, OSError):
+            stream.reconfigure(line_buffering=True)  # type: ignore[union-attr]
+
+    level_name = os.environ.get("LOGLEVEL", "DEBUG").upper()
+    level = getattr(logging, level_name, logging.DEBUG)
+    logging.getLogger("code_generator").setLevel(level)
+
+
+_configure_io_and_logging()
+
+app = typer.Typer(
+    name="code-generator",
+    help="Orchestrate Claude Code to generate whole projects from a requirements.md.",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"code-generator {code_generator.__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def root(
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    """code-generator CLI root."""
+
+
+app.add_typer(bench_app, name="bench")
+app.add_typer(generate_app, name="generate")
+app.command(name="init")(init_command)
+app.command(name="status")(status_command)
+app.command(name="optimize")(optimize_command)
+app.command(name="review")(review_command)

{claude_code_generator-0.5.3 → claude_code_generator-0.5.5}/src/code_generator/logging_setup.py

@@ -3,9 +3,14 @@
 Each phase gets its own log file under .code-generator/logs/ and a shared
 RichHandler for colour-coded console output. The setup is idempotent: calling
 setup_phase_logger() twice for the same phase does not duplicate handlers.
+
+The default console level is DEBUG, overridable via the ``LOGLEVEL`` env var
+(``LOGLEVEL=INFO`` for the quieter behaviour shipped in 0.4.x). The file
+handler always writes at DEBUG so post-mortem inspection retains everything.
 """
 
 import logging
+import os
 from pathlib import Path
 
 from rich.logging import RichHandler
@@ -13,11 +18,19 @@ from rich.logging import RichHandler
 _FILE_FORMATTER = logging.Formatter("%(asctime)s %(levelname)s %(message)s")
 
 
+def _resolve_level(default: int = logging.DEBUG) -> int:
+    """Read the ``LOGLEVEL`` env var, falling back to *default* on miss/typo."""
+    name = os.environ.get("LOGLEVEL", "").upper()
+    if not name:
+        return default
+    return getattr(logging, name, default)
+
+
 def setup_phase_logger(
     phase_name: str,
     project_dir: Path,
     *,
-    level: int = logging.INFO,
+    level: int | None = None,
 ) -> logging.Logger:
     """Configure and return a logger for a single orchestration phase.
 
@@ -29,21 +42,23 @@ def setup_phase_logger(
         phase_name: Short identifier for the phase (e.g. ``"planning"``).
         project_dir: Root directory of the user's project. Logs are written to
             ``project_dir / ".code-generator" / "logs" / f"{phase_name}.log"``.
-        level: Python logging level applied to the logger. Defaults to INFO.
+        level: Python logging level applied to the logger.  Defaults to the
+            value of the ``LOGLEVEL`` env var, or DEBUG if unset.
 
     Returns:
         Configured :class:`logging.Logger` instance.
     """
+    effective_level = level if level is not None else _resolve_level()
     logger = logging.getLogger(f"code_generator.phase.{phase_name}")
 
     if _already_configured(logger):
         return logger
 
-    logger.setLevel(level)
+    logger.setLevel(effective_level)
     logger.propagate = False
 
     _attach_file_handler(logger, project_dir, phase_name)
-    _attach_rich_handler(logger)
+    _attach_rich_handler(logger, effective_level)
 
     return logger
 
@@ -67,9 +82,9 @@ def _attach_file_handler(
     logger.addHandler(handler)
 
 
-def _attach_rich_handler(logger: logging.Logger) -> None:
+def _attach_rich_handler(logger: logging.Logger, level: int) -> None:
     handler = RichHandler(show_time=False, show_path=False)
-    handler.setLevel(logging.INFO)
+    handler.setLevel(level)
     logger.addHandler(handler)
 
 

{claude_code_generator-0.5.3 → claude_code_generator-0.5.5}/src/code_generator/runner/message_parsing.py

@@ -94,6 +94,128 @@ def is_result_message(msg: Any) -> bool:
     )
 
 
+def is_system_message(msg: Any) -> bool:
+    """Return True when msg looks like a SDK ``SystemMessage``.
+
+    Duck-typed: SystemMessage carries a ``subtype`` (e.g. ``"init"``) and an
+    optional ``data`` dict, while not having the discriminating attributes of
+    AssistantMessage (``model``) or ResultMessage (``is_error``).
+    """
+    return (
+        hasattr(msg, "subtype")
+        and not hasattr(msg, "model")
+        and not hasattr(msg, "is_error")
+        and not hasattr(msg, "rate_limit_info")
+    )
+
+
+def is_user_message(msg: Any) -> bool:
+    """Return True when msg looks like a SDK ``UserMessage``.
+
+    Duck-typed: UserMessage has ``content`` (a list of blocks) and a
+    ``role`` of ``"user"``, but not the AssistantMessage ``model`` field.
+    """
+    role = getattr(msg, "role", None)
+    return (
+        role == "user"
+        and hasattr(msg, "content")
+        and not hasattr(msg, "model")
+        and not hasattr(msg, "is_error")
+    )
+
+
+def render_system_message(msg: Any) -> str:
+    """Format a SystemMessage's ``subtype`` + ``data`` payload for DEBUG logs.
+
+    Full payload — no truncation. Large ``data`` values can produce long
+    lines; that is intentional so users running with ``LOGLEVEL=DEBUG`` see
+    exactly what the SDK emitted.
+    """
+    subtype = getattr(msg, "subtype", None)
+    data = getattr(msg, "data", None)
+    if subtype is None and data is None:
+        return type(msg).__name__
+
+    if isinstance(data, dict):
+        previews = [f"{k}={v!r}" for k, v in data.items()]
+        body = " ".join(previews) if previews else "<empty>"
+    elif data is None:
+        body = "<no data>"
+    else:
+        body = repr(data)
+
+    return f"subtype={subtype} {body}"
+
+
+def render_blocks(content: Any) -> str:
+    """Render an SDK message's ``content`` (list of blocks) verbatim.
+
+    Handles every block shape the agent SDK currently emits:
+    - **TextBlock** (``.text``) → ``text: <body>``
+    - **ToolUseBlock** (``.name``, ``.input``) → ``tool_use(name): {args}``
+    - **ToolResultBlock** (``.tool_use_id``, ``.content``) → ``tool_result(id): <body>``
+    - **ThinkingBlock** (``.thinking``) → ``thinking: <body>``
+    - Anything else falls through to the class name.
+
+    No truncation: tool results, prompts, and thinking blocks render in
+    full. Long lines are intentional so DEBUG logs are lossless.
+
+    Args:
+        content: The message's ``content`` attribute. Lists are walked
+            block-by-block; non-lists are repr'd directly.
+
+    Returns:
+        A single string suitable for a DEBUG log line.
+    """
+    if not isinstance(content, list):
+        return repr(content)
+
+    if not content:
+        return "<empty>"
+
+    return " | ".join(_render_block(block) for block in content)
+
+
+def _render_block(block: Any) -> str:
+    """Render a single content block — see :func:`render_blocks`."""
+    if hasattr(block, "text") and isinstance(block.text, str):
+        return f"text: {block.text}"
+    if hasattr(block, "name") and hasattr(block, "input"):
+        return f"tool_use({block.name}): {block.input!r}"
+    if hasattr(block, "tool_use_id"):
+        result = getattr(block, "content", "<no content>")
+        is_error = bool(getattr(block, "is_error", False))
+        body = _render_tool_result(result)
+        prefix = "tool_result_error" if is_error else "tool_result"
+        return f"{prefix}({block.tool_use_id}): {body}"
+    if hasattr(block, "thinking") and isinstance(block.thinking, str):
+        return f"thinking: {block.thinking}"
+    return type(block).__name__
+
+
+def _render_tool_result(content: Any) -> str:
+    """Render a ToolResultBlock's ``.content`` (str | list[block] | other) verbatim."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        chunks: list[str] = []
+        for item in content:
+            text = getattr(item, "text", None)
+            if isinstance(text, str):
+                chunks.append(text)
+            elif isinstance(item, dict) and isinstance(item.get("text"), str):
+                chunks.append(item["text"])
+            else:
+                chunks.append(repr(item))
+        return " / ".join(chunks) if chunks else "<empty>"
+    return repr(content)
+
+
+def render_prompt(prompt: str) -> str:
+    """Return the outgoing prompt verbatim for DEBUG logging (no truncation)."""
+    return prompt
+
+
 def is_context_edit_message(msg: Any) -> bool:
     """Return True when msg looks like a CompactionResult or ContextEditResult.
 

{claude_code_generator-0.5.3 → claude_code_generator-0.5.5}/src/code_generator/runner/sdk_runner.py

@@ -18,6 +18,11 @@ from code_generator.runner.message_parsing import (
     is_context_edit_message,
     is_rate_limit_event,
     is_result_message,
+    is_system_message,
+    is_user_message,
+    render_blocks,
+    render_prompt,
+    render_system_message,
 )
 from code_generator.runner.types import (
     ApiUpstreamError,
@@ -145,7 +150,14 @@ async def _drain_messages(
                     chunk.rstrip(),
                 )
             else:
-                logger.debug("msg #%d: assistant (empty)", msg_count)
+                # No text content — almost always a tool_use block. Render it
+                # at DEBUG so users can trace exactly which tool the model
+                # invoked and with what arguments.
+                logger.debug(
+                    "msg #%d: assistant (tool_use) %s",
+                    msg_count,
+                    render_blocks(getattr(msg, "content", None)),
+                )
             # Some SDK versions attach session_id to AssistantMessage.
             if session_id is None:
                 session_id = getattr(msg, "session_id", None)
@@ -202,8 +214,33 @@ async def _drain_messages(
                     f"tokens_out={usage.output}): {tail}"
                 )
             break
+        elif is_system_message(msg):
+            logger.debug("msg #%d: SystemMessage %s", msg_count, render_system_message(msg))
+        elif is_user_message(msg):
+            logger.debug(
+                "msg #%d: UserMessage %s",
+                msg_count,
+                render_blocks(getattr(msg, "content", None)),
+            )
         else:
-            logger.debug("msg #%d: %s", msg_count, type(msg).__name__)
+            # Catch-all for less common message types (TaskStartedMessage,
+            # TaskFinishedMessage, etc.). Render any ``content`` /
+            # ``data`` / ``message`` payload we can find so the type-name
+            # alone is never the only signal.
+            payload = (
+                getattr(msg, "content", None)
+                or getattr(msg, "data", None)
+                or getattr(msg, "message", None)
+            )
+            if payload is not None:
+                logger.debug(
+                    "msg #%d: %s %s",
+                    msg_count,
+                    type(msg).__name__,
+                    render_blocks(payload),
+                )
+            else:
+                logger.debug("msg #%d: %s", msg_count, type(msg).__name__)
 
     return "".join(text_parts), session_id, usage or TokenUsage()
 
@@ -256,6 +293,11 @@ async def run(
         getattr(options, "effort", None) or "default",
         getattr(options, "max_turns", "?"),
     )
+    logger.debug(
+        "SDK prompt (%d chars):\n%s",
+        len(prompt),
+        render_prompt(prompt),
+    )
 
     t0 = time.monotonic()
     async with ClaudeSDKClient(options=options) as client:
@@ -311,6 +353,11 @@ async def run_with_shared_client(
         getattr(options, "effort", None) or "default",
         getattr(options, "max_turns", "?"),
     )
+    logger.debug(
+        "SDK prompt (%d chars):\n%s",
+        len(prompt),
+        render_prompt(prompt),
+    )
 
     t0 = time.monotonic()
     await client.query(prompt)

claude_code_generator-0.5.5/tests/test_cli_io_logging.py

@@ -0,0 +1,73 @@
+"""Tests for ``cli._configure_io_and_logging``.
+
+The CLI applies two startup defaults so users don't need to set env vars
+manually: line-buffered stdout/stderr (PYTHONUNBUFFERED=1) and DEBUG-level
+console logging (LOGLEVEL=DEBUG).  Both are overridable via ``LOGLEVEL``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from code_generator import cli
+
+if TYPE_CHECKING:
+    import pytest
+
+
+class TestConfigureIoAndLogging:
+    """``_configure_io_and_logging`` sets sane defaults at CLI startup."""
+
+    def test_default_loglevel_is_debug(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """When ``LOGLEVEL`` is unset, the code_generator namespace uses DEBUG."""
+        monkeypatch.delenv("LOGLEVEL", raising=False)
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.DEBUG
+
+    def test_loglevel_env_overrides_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """``LOGLEVEL=INFO`` reverts to the quieter 0.4.x default."""
+        monkeypatch.setenv("LOGLEVEL", "INFO")
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.INFO
+
+    def test_unknown_loglevel_falls_back_to_debug(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Typos like ``LOGLEVEL=NOPE`` fall back to DEBUG, not raise."""
+        monkeypatch.setenv("LOGLEVEL", "NOPE")
+        cli._configure_io_and_logging()
+
+        assert logging.getLogger("code_generator").level == logging.DEBUG
+
+    def test_idempotent_when_called_twice(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Calling twice in a row does not raise (e.g. on `--version` re-import)."""
+        monkeypatch.setenv("LOGLEVEL", "INFO")
+        cli._configure_io_and_logging()
+        cli._configure_io_and_logging()  # must not raise
+
+        assert logging.getLogger("code_generator").level == logging.INFO
+
+    def test_stdout_is_line_buffered_after_setup(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """sys.stdout / sys.stderr must report line buffering after setup.
+
+        On terminals where stdout is already line-buffered, this is a no-op;
+        when running through a pipe (default block buffering), the call
+        switches the stream to line buffering.
+        """
+        import sys
+
+        monkeypatch.delenv("LOGLEVEL", raising=False)
+        cli._configure_io_and_logging()
+
+        # `line_buffering` attribute exists on TextIOWrapper. After
+        # reconfigure(line_buffering=True), it must be True.  Streams that
+        # don't support the attribute (rare) are intentionally tolerated.
+        for stream in (sys.stdout, sys.stderr):
+            buffering = getattr(stream, "line_buffering", None)
+            if buffering is not None:
+                assert buffering is True, f"{stream} not line-buffered"

{claude_code_generator-0.5.3 → claude_code_generator-0.5.5}/tests/test_message_parsing.py

@@ -483,3 +483,168 @@ def test_handle_rate_limit_event_rejected_without_resets_at_logs_warning(
         handle_rate_limit_event(event, logger, state_path)
 
     assert any("no resets_at" in r.message for r in caplog.records)
+
+
+# ---------------------------------------------------------------------------
+# render_blocks / render_system_message / render_prompt / new predicates
+# ---------------------------------------------------------------------------
+
+
+class FakeToolUseBlock:
+    def __init__(self, name: str, input_data: dict) -> None:
+        self.name = name
+        self.input = input_data
+        self.id = "tu-x"
+
+
+class FakeToolResultBlock:
+    def __init__(self, tool_use_id: str, content, is_error: bool = False) -> None:
+        self.tool_use_id = tool_use_id
+        self.content = content
+        self.is_error = is_error
+
+
+class FakeThinkingBlock:
+    def __init__(self, thinking: str) -> None:
+        self.thinking = thinking
+
+
+class FakeSystemMessage:
+    def __init__(self, subtype: str, data: dict | None = None) -> None:
+        self.subtype = subtype
+        self.data = data
+
+
+class FakeUserMessage:
+    def __init__(self, content) -> None:
+        self.role = "user"
+        self.content = content
+
+
+def test_render_blocks_handles_text_block() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks([FakeTextBlock("hello world")])
+    assert rendered == "text: hello world"
+
+
+def test_render_blocks_handles_tool_use_block() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks([FakeToolUseBlock("Read", {"file_path": "/tmp/x.py"})])
+    assert rendered.startswith("tool_use(Read): ")
+    assert "/tmp/x.py" in rendered
+
+
+def test_render_blocks_handles_tool_result_block_str() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks([FakeToolResultBlock("tu-1", "result body")])
+    assert rendered == "tool_result(tu-1): result body"
+
+
+def test_render_blocks_marks_tool_result_errors() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks(
+        [FakeToolResultBlock("tu-2", "boom", is_error=True)]
+    )
+    assert rendered.startswith("tool_result_error(tu-2): ")
+
+
+def test_render_blocks_handles_thinking_block() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks([FakeThinkingBlock("planning step…")])
+    assert rendered == "thinking: planning step…"
+
+
+def test_render_blocks_renders_long_text_in_full() -> None:
+    """No truncation — full text is preserved so DEBUG logs are lossless."""
+    from code_generator.runner.message_parsing import render_blocks
+
+    long = "x" * 5000
+    rendered = render_blocks([FakeTextBlock(long)])
+    assert rendered == f"text: {long}"
+    assert "truncated" not in rendered
+
+
+def test_render_blocks_joins_multiple_with_pipe() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    rendered = render_blocks(
+        [
+            FakeTextBlock("first"),
+            FakeToolUseBlock("Read", {"path": "a.py"}),
+        ]
+    )
+    assert " | " in rendered
+    assert "text: first" in rendered
+    assert "tool_use(Read)" in rendered
+
+
+def test_render_blocks_empty_list_returns_marker() -> None:
+    from code_generator.runner.message_parsing import render_blocks
+
+    assert render_blocks([]) == "<empty>"
+
+
+def test_render_system_message_with_subtype_and_data() -> None:
+    from code_generator.runner.message_parsing import render_system_message
+
+    msg = FakeSystemMessage("init", {"model": "claude-opus-4-7", "session_id": "s1"})
+    rendered = render_system_message(msg)
+    assert rendered.startswith("subtype=init")
+    assert "model=" in rendered
+    assert "session_id=" in rendered
+
+
+def test_render_system_message_subtype_only() -> None:
+    from code_generator.runner.message_parsing import render_system_message
+
+    msg = FakeSystemMessage("compaction", None)
+    rendered = render_system_message(msg)
+    assert rendered.startswith("subtype=compaction")
+    assert "no data" in rendered
+
+
+def test_is_system_message_predicate() -> None:
+    from code_generator.runner.message_parsing import is_system_message
+
+    assert is_system_message(FakeSystemMessage("init"))
+    assert not is_system_message(FakeAssistantMessage("hi"))
+    assert not is_system_message(FakeUserMessage([FakeTextBlock("hi")]))
+
+
+def test_is_user_message_predicate() -> None:
+    from code_generator.runner.message_parsing import is_user_message
+
+    assert is_user_message(FakeUserMessage([FakeTextBlock("hi")]))
+    assert not is_user_message(FakeSystemMessage("init"))
+    assert not is_user_message(FakeAssistantMessage("hi"))
+
+
+def test_render_prompt_renders_long_input_verbatim() -> None:
+    """No truncation — prompts log in full so the model's exact input is auditable."""
+    from code_generator.runner.message_parsing import render_prompt
+
+    long = "y" * 5000
+    rendered = render_prompt(long)
+    assert rendered == long
+    assert "truncated" not in rendered
+
+
+def test_render_prompt_passthrough_short_input() -> None:
+    from code_generator.runner.message_parsing import render_prompt
+
+    assert render_prompt("hello") == "hello"
+
+
+def test_render_blocks_renders_long_tool_result_in_full() -> None:
+    """Tool results render verbatim — no body cap."""
+    from code_generator.runner.message_parsing import render_blocks
+
+    long = "z" * 5000
+    rendered = render_blocks([FakeToolResultBlock("tu-9", long)])
+    assert rendered == f"tool_result(tu-9): {long}"
+    assert "truncated" not in rendered