fix: end every render's log file with what the render did

The exit summary reaches the terminal through Rich's print, which never touches
logging, so codeplain.log simply stopped at whatever happened to be logged last.
An artifact that ends mid-render is indistinguishable from a process that died
silently — originally noted for hycu's ConflictingRequirements abort, and it
just blocked a real diagnosis: cli-password-manager in
codeplain-tty-capability-run2 rendered to completion (22 functionalities,
48m54s) yet delivered a build with no CLI entry point, and the captured log
ended at 01:29:57 mid-render with no record of how it finished.

Adds a trailer written through the codeplain logger — so it lands in the log
file — on every exit path, since print_exit_summary is called from a finally:

    [render-trailer] outcome=completed render_id=... functionalities=22
        render_time_s=2934 generated_code=- spec=vault_cli...plain
    [render-trailer] error=<reason>          (failed renders only)

Handlers are flushed explicitly; a process exiting immediately after would
otherwise defeat the point of writing it.

The trailer doubles as a probe: because it is written unconditionally, a
captured log *without* one proves the file was truncated rather than merely
uninformative — which is the open question behind the missing entry point.

Author: gorandodig

cli_output/render_summary.py

@@ -1,11 +1,19 @@
 """Render completion summary display."""
 
+import logging
 from typing import Optional
 
+import plain2code_logger
 from plain2code_console import console
 from plain2code_state import RunState
 from usage_summary import format_usage_summary
 
+logger = logging.getLogger(plain2code_logger.LOGGER_NAME)
+
+# Marks the last line of a render's log file. Greppable on purpose: benchmark runs and
+# support artifacts are read by tooling before they are read by a person.
+RENDER_TRAILER_PREFIX = "[render-trailer]"
+
 
 def print_exit_summary(
     run_state: RunState,
@@ -30,3 +38,42 @@ def print_exit_summary(
     if not run_state.render_succeeded and error_message:
         console.error(error_message)
     console.quiet = True
+
+    log_render_trailer(run_state, spec_filename, error_message)
+
+
+def log_render_trailer(
+    run_state: RunState,
+    spec_filename: str,
+    error_message: Optional[str] = None,
+) -> None:
+    """Writes the render's outcome to the log file, as its last line.
+
+    The summary above reaches the terminal through Rich, which never touches logging, so
+    a captured `codeplain.log` used to stop at whatever happened to be logged last —
+    indistinguishable from a process that died silently. This ends every log with what
+    the render did, and because it is written on every exit path a log *without* a
+    trailer is itself evidence that the file was truncated.
+    """
+    if run_state.render_succeeded:
+        outcome = "completed"
+    elif run_state.render_cancelled:
+        outcome = "cancelled"
+    else:
+        outcome = "failed"
+
+    logger.info(
+        f"{RENDER_TRAILER_PREFIX} outcome={outcome} "
+        f"render_id={run_state.render_id} "
+        f"functionalities={run_state.rendered_functionalities} "
+        f"render_time_s={run_state.render_time_accumulated} "
+        f"generated_code={run_state.render_generated_code_path or '-'} "
+        f"spec={spec_filename}"
+    )
+    if outcome == "failed" and error_message:
+        logger.error(f"{RENDER_TRAILER_PREFIX} error={error_message}")
+
+    # The process may exit immediately after this; an unflushed trailer would defeat the
+    # purpose of writing one.
+    for handler in logger.handlers:
+        handler.flush()

tests/test_render_trailer.py

@@ -0,0 +1,101 @@
+"""Tests for the render trailer written to the log file.
+
+The pretty exit summary goes out through Rich's print, which bypasses logging entirely,
+so `codeplain.log` simply stopped at whatever was logged last. An artifact that ends
+mid-render is indistinguishable from a process that died silently — and when
+cli-password-manager delivered a build with no entry point, that missing ending is
+exactly what blocked the diagnosis.
+
+The trailer is therefore both the fix and a probe: it is the last thing written on every
+exit path, so an artifact without one proves the log was truncated rather than merely
+uninformative.
+"""
+
+import logging
+from unittest.mock import MagicMock
+
+import pytest
+
+from cli_output.render_summary import RENDER_TRAILER_PREFIX, log_render_trailer
+
+
+def run_state(succeeded=True, cancelled=False):
+    state = MagicMock()
+    state.render_succeeded = succeeded
+    state.render_cancelled = cancelled
+    state.render_id = "5f1c25b7"
+    state.rendered_functionalities = 22
+    state.render_time_accumulated = 2934
+    state.render_generated_code_path = "/int-plainlang-examples/cli-password-manager/dist/"
+    return state
+
+
+@pytest.fixture
+def trailer_lines(caplog):
+    caplog.set_level(logging.INFO, logger="codeplain")
+
+    def emit(state, spec="vault_cli.plain", error_message=None):
+        caplog.clear()
+        log_render_trailer(state, spec, error_message)
+        return [record.getMessage() for record in caplog.records if RENDER_TRAILER_PREFIX in record.getMessage()]
+
+    return emit
+
+
+def test_a_completed_render_records_its_outcome(trailer_lines):
+    lines = trailer_lines(run_state())
+
+    assert len(lines) == 1
+    assert "outcome=completed" in lines[0]
+
+
+def test_the_trailer_carries_what_a_later_diagnosis_needs(trailer_lines):
+    lines = trailer_lines(run_state())
+
+    assert "render_id=5f1c25b7" in lines[0]
+    assert "functionalities=22" in lines[0]
+    assert "render_time_s=2934" in lines[0]
+    assert "generated_code=/int-plainlang-examples/cli-password-manager/dist/" in lines[0]
+
+
+def test_a_missing_generated_code_path_is_explicit(trailer_lines):
+    """The run that delivered no entry point reported this field empty; it has to be
+    legible in the log rather than a blank gap."""
+    state = run_state()
+    state.render_generated_code_path = None
+
+    lines = trailer_lines(state)
+
+    assert "generated_code=-" in lines[0]
+
+
+def test_a_failed_render_records_the_reason(trailer_lines):
+    lines = trailer_lines(run_state(succeeded=False), error_message="Conformance tests could not be fixed.")
+
+    assert any("outcome=failed" in line for line in lines)
+    assert any("error=Conformance tests could not be fixed." in line for line in lines)
+
+
+def test_a_cancelled_render_is_not_reported_as_failed(trailer_lines):
+    lines = trailer_lines(run_state(succeeded=False, cancelled=True))
+
+    assert "outcome=cancelled" in lines[0]
+
+
+def test_a_failure_without_a_message_still_ends_the_log(trailer_lines):
+    lines = trailer_lines(run_state(succeeded=False))
+
+    assert any("outcome=failed" in line for line in lines)
+
+
+def test_the_trailer_is_flushed_so_it_survives_an_abrupt_exit():
+    handler = MagicMock()
+    handler.level = logging.NOTSET  # logging compares record.levelno against this
+    logger = logging.getLogger("codeplain")
+    logger.addHandler(handler)
+    try:
+        log_render_trailer(run_state(), "vault_cli.plain")
+    finally:
+        logger.removeHandler(handler)
+
+    assert handler.flush.called