@@ -15,6 +15,20 @@
 RENDER_TRAILER_PREFIX = "[render-trailer]"
 
 
+def render_outcome(run_state: RunState, error_message: Optional[str]) -> str:
+    """What the render did, for the banner and the trailer alike.
+
+    A reason recorded on the way out overrides the success flag. The flag is set per
+    module, so an earlier module's success can still be standing while the process exits
+    on an error - which read as a completed render that produced nothing.
+    """
+    if run_state.render_succeeded and not error_message:
+        return "completed"
+    if run_state.render_cancelled:
+        return "cancelled"
+    return "failed"
+
+
 def print_exit_summary(
     run_state: RunState,
     spec_filename: str,
@@ -23,7 +37,7 @@ def print_exit_summary(
     """Print render outcome after the TUI exits (terminal restored)."""
     console.quiet = False
 
-    if run_state.render_succeeded:
+    if render_outcome(run_state, error_message) == "completed":
         msg = "\n[#79FC96]✓ rendering completed\n\n"
     elif run_state.render_cancelled:
         msg = "\n[#FFFFFF]— rendering canceled\n\n"
@@ -59,12 +73,7 @@ def log_render_trailer(
     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"
+    outcome = render_outcome(run_state, error_message)
 
     # Both times: an action that raises never reaches the render's own terminal accounting,
     # so the banked figure is stale on the paths this trailer exists to describe, and the
 
@@ -143,7 +143,11 @@ def post_request(
                     self.console.debug(f"Failed to decode JSON response: {e}. Response text: {response.text}")
                     raise Exception(f"Error rendering plain code: Failed to decode API response ({e}).\n") from e
 
-                if response.status_code == requests.codes.bad_request and "error_code" in response_json:
+                # Any status the server declines on, not only 400. The server returns
+                # error_code with 500 as well, and reading it only on 400 meant those
+                # reached the user as the raw "500 Server Error for url: ..." rather than
+                # the message the code was paired with.
+                if not response.ok and "error_code" in response_json:
                     self._raise_for_error_code(response_json)
 
                 response.raise_for_status()
 
@@ -192,6 +192,25 @@ def warn_if_acceptance_tests_without_conformance_script(plain_module, args) -> N
     )
 
 
+def _render_recording_outcome(module_renderer, run_state: RunState) -> Exception | None:
+    """Runs the render and records how it ended, returning the failure if there was one.
+
+    The outcome is recorded per module, so a render that fails after an earlier module has
+    completed is still holding that module's success. Both the render trailer and the
+    headless exit code read that flag, and the exit code is 0 when the failure is one of
+    EXPECTED_EXCEPTIONS - so a caller that skips this reports a failed render as a
+    successful one.
+    """
+    try:
+        module_renderer.render_module()
+    except RenderCancelledError:
+        run_state.set_render_cancelled()  # The TUI is already closed, nothing to report.
+    except Exception as error:
+        run_state.set_render_succeeded(False)
+        return error
+    return None
+
+
 def render(  # noqa: C901
     plain_module: plain_modules.PlainModule,
     args,
@@ -285,21 +304,16 @@ def render(  # noqa: C901
     render_error: list[Exception] = []
 
     def run_render():
-        try:
-            module_renderer.render_module()
-        except RenderCancelledError:
-            run_state.set_render_cancelled()  # TUI already closed, nothing to report
-        except Exception as e:
-            run_state.set_render_succeeded(False)
-            render_error.append(e)
-            event_bus.publish(RenderFailed(error_message=str(e)))
+        error = _render_recording_outcome(module_renderer, run_state)
+        if error is not None:
+            render_error.append(error)
+            event_bus.publish(RenderFailed(error_message=str(error)))
 
     if args.headless:
         console.info(f"Render started. Render ID: {run_state.render_id}")
-        try:
-            module_renderer.render_module()
-        except RenderCancelledError:
-            run_state.set_render_cancelled()
+        error = _render_recording_outcome(module_renderer, run_state)
+        if error is not None:
+            raise error
         return
     else:
         render_thread = threading.Thread(target=run_render, daemon=True)
 
@@ -1,10 +1,12 @@
 import tempfile
 from argparse import Namespace
 from types import SimpleNamespace
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import plain2code
 import plain_spec
+from plain2code_exceptions import RenderCancelledError
+from plain2code_state import RunState
 from plain_modules import PlainModule
 
 
@@ -91,3 +93,42 @@ def test_warning_covers_required_modules_for_real_plain_module(get_test_data_pat
     mock_console.warning.assert_called_once()
     warning_message = mock_console.warning.call_args.args[0]
     assert "required_with_acceptance_tests" in warning_message
+
+
+class TestRenderRecordsItsOutcome:
+    """The headless path and the TUI path both have to record how the render ended. Only
+    the TUI path did, so a headless render that failed after one module had completed
+    reported `outcome=completed` and, when the failure was an expected exception, exited 0.
+    """
+
+    @staticmethod
+    def _renderer(error=None):
+        renderer = MagicMock()
+        if error is not None:
+            renderer.render_module.side_effect = error
+        return renderer
+
+    def test_a_failure_clears_a_success_left_by_an_earlier_module(self):
+        run_state = RunState("reports.plain")
+        run_state.set_render_succeeded(True)
+        failure = RuntimeError("conformance fix loop exhausted")
+
+        returned = plain2code._render_recording_outcome(self._renderer(failure), run_state)
+
+        assert returned is failure
+        assert run_state.render_succeeded is False
+
+    def test_a_clean_run_leaves_the_outcome_alone(self):
+        run_state = RunState("reports.plain")
+        run_state.set_render_succeeded(True)
+
+        assert plain2code._render_recording_outcome(self._renderer(), run_state) is None
+        assert run_state.render_succeeded is True
+
+    def test_cancellation_is_recorded_as_cancelled_rather_than_returned(self):
+        run_state = RunState("reports.plain")
+
+        returned = plain2code._render_recording_outcome(self._renderer(RenderCancelledError()), run_state)
+
+        assert returned is None
+        assert run_state.render_cancelled is True
@@ -104,15 +104,19 @@ def test_the_trailer_is_flushed_so_it_survives_an_abrupt_exit():
     assert handler.flush.called
 
 
-def test_a_completed_render_that_still_raised_reports_the_reason(trailer_lines):
+def test_a_render_that_raised_on_the_way_out_reports_the_reason_and_fails(trailer_lines):
     """A render can finish its functionalities and raise on the way out — publishing the
-    build, for instance. That combination printed a success banner, logged no reason, and
-    exited non-zero, which is how a failure on the publish path went unnoticed across a
-    whole run."""
+    build, for instance. That combination printed a success banner and logged no reason,
+    which is how a failure on the publish path went unnoticed across a whole run.
+
+    The reason belongs on the trailer, and so does an outcome that agrees with it: the
+    success flag is set per module, so an earlier module's success outlives the failure of
+    a later one, and a run that produced no build reported `outcome=completed`."""
     lines = trailer_lines(run_state(succeeded=True), error_message="The generated build references ...")
 
-    assert any("outcome=completed" in line for line in lines)
     assert any("error='The generated build references ...'" in line for line in lines)
+    assert any("outcome=failed" in line for line in lines)
+    assert not any("outcome=completed" in line for line in lines)
 
 
 def test_a_multi_line_reason_still_leaves_the_trailer_on_one_line(trailer_lines):
@@ -124,3 +128,18 @@ def test_a_multi_line_reason_still_leaves_the_trailer_on_one_line(trailer_lines)
     assert "\n" not in lines[0]
     assert "outcome=failed" in lines[0]
     assert "second line" in lines[0]
+
+
+class TestOutcomeAgreesWithTheReason:
+    """A trailer that says `completed` next to an `error=` is worse than no trailer: it is
+    read by tooling, and it was observed on a render that produced no code at all. The
+    success flag is set per module, so an earlier module's success outlives the failure of
+    a later one."""
+
+    def test_success_with_no_error_still_completes(self, trailer_lines):
+        assert "outcome=completed" in trailer_lines(run_state(succeeded=True))[0]
+
+    def test_a_cancelled_render_reports_cancelled_not_failed(self, trailer_lines):
+        lines = trailer_lines(run_state(succeeded=False, cancelled=True), error_message="Keyboard interrupt")
+
+        assert "outcome=cancelled" in lines[0]
@@ -1,15 +1,16 @@
 """Tests for mapping API error codes onto typed client exceptions."""
 
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import pytest
+import requests
 
 import plain2code_exceptions
 from codeplain_REST_api import CodeplainAPI
 
 
 def test_conformance_fix_exhaustion_maps_to_its_typed_exception():
-    """The server reports fix-attempt exhaustion as a structured 400; the client raises
+    """The server reports fix-attempt exhaustion as a structured error; the client raises
     the matching typed exception so the render fails with the server's message instead
     of a raw HTTP error."""
     api = CodeplainAPI(api_key="test-key", console=MagicMock())
@@ -35,3 +36,49 @@ def test_the_exhaustion_error_is_expected_rather_than_a_crash():
     from plain2code import EXPECTED_EXCEPTIONS
 
     assert plain2code_exceptions.ConformanceTestsFixExhausted in EXPECTED_EXCEPTIONS
+
+
+class TestErrorCodesAreReadOnEveryDeclinedStatus:
+    """The client used to consult `error_code` only on 400, so every structured error the
+    server returns with a 500 - its own `InternalServerError` among them - reached the user
+    as `500 Server Error: INTERNAL SERVER ERROR for url: <internal endpoint>`. The message
+    the code was paired with never printed."""
+
+    @staticmethod
+    def _api_returning(status, body):
+        response = MagicMock()
+        response.status_code = status
+        response.ok = 200 <= status < 300
+        response.json.return_value = body
+        response.raise_for_status.side_effect = requests.exceptions.HTTPError(f"{status} Server Error")
+
+        api = CodeplainAPI(api_key="test-key", console=MagicMock())
+        api.api_url = "https://api.example"
+        return api, response
+
+    def test_a_500_carrying_an_error_code_raises_the_typed_exception(self):
+        api, response = self._api_returning(
+            500,
+            {
+                "error_code": "ConformanceTestsFixExhausted",
+                "message": "The conformance tests for functionality 1 still failed.",
+            },
+        )
+
+        with patch("requests.post", return_value=response):
+            with pytest.raises(plain2code_exceptions.ConformanceTestsFixExhausted, match="still failed"):
+                api.post_request("https://api.example/x", {}, {}, None, num_retries=0)
+
+    def test_the_generic_server_error_reaches_the_user_as_its_own_message(self):
+        api, response = self._api_returning(500, {"error_code": "InternalServerError", "message": "boom"})
+
+        with patch("requests.post", return_value=response):
+            with pytest.raises(plain2code_exceptions.InternalServerError, match="support@codeplain.ai"):
+                api.post_request("https://api.example/x", {}, {}, None, num_retries=0)
+
+    def test_a_success_is_returned_untouched(self):
+        api, response = self._api_returning(200, {"result": "ok"})
+        response.raise_for_status.side_effect = None
+
+        with patch("requests.post", return_value=response):
+            assert api.post_request("https://api.example/x", {}, {}, None, num_retries=0) == {"result": "ok"}