fix: report why a render failed instead of a raw payload

A/B arm ab-no-analyze-plus-tty-no-prompts gave up on python_tui at FRID 1
inside the unit-test fix loop and told the user only:

    ERROR codeplain: None

ExitWithError printed whatever payload the failing action handed over, and
actions reach that state by three routes: an encoded RenderError dict, a plain
string, or nothing at all. The last route printed "None"; the first printed a
raw dict repr, which is what the conformance-fix-exhausted path has been
showing all along:

    ERROR codeplain: {'error': {'message': "The renderer was unable to ...",
                                'type': None, 'details': None}}

Unwraps the reason at the log site and falls back to last_error_message, the
same message the returned payload already carried — so the line a user reads
is never less informative than the error the renderer returns.

Author: gorandodig

render_machine/actions/exit_with_error.py

@@ -10,7 +10,7 @@ class ExitWithError(BaseAction):
     SUCCESSFUL_OUTCOME = "error_handled"
 
     def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
-        console.error(previous_action_payload)
+        console.error(self._error_message(render_context, previous_action_payload))
 
         render_context.codeplain_api.fail_functional_requirement(
             render_context.frid_context.frid,
@@ -33,3 +33,22 @@ def execute(self, render_context: RenderContext, previous_action_payload: Any |
                 message=render_context.last_error_message or "Unknown error",
             ).to_payload(),
         )
+
+    @staticmethod
+    def _error_message(render_context: RenderContext, previous_action_payload: Any | None) -> str:
+        """What the user is told the render stopped for.
+
+        Actions reach this state by three routes: some hand over an encoded RenderError
+        payload, some a plain string, and some nothing at all. Printing the payload as it
+        arrives showed a raw dict for the first and the word "None" for the last, so the
+        reason is unwrapped here and falls back to the same message the returned payload
+        carries.
+        """
+        if isinstance(previous_action_payload, dict):
+            error = previous_action_payload.get("error")
+            if isinstance(error, dict) and error.get("message"):
+                return error["message"]
+        elif previous_action_payload:
+            return str(previous_action_payload)
+
+        return render_context.last_error_message or "Unknown error"

tests/test_exit_with_error.py

@@ -0,0 +1,65 @@
+"""The operator-facing message on a failed render.
+
+`ExitWithError` prints the payload the failing action handed over, but not every path
+into it supplies one — a render that gave up inside the unit-test fix loop arrives with
+`None`, and the user was shown a bare `ERROR codeplain: None` with no reason. The encoded
+payload already falls back to `last_error_message`; the console line must agree, so the
+message a user sees is never less informative than the one the renderer returns.
+"""
+
+from unittest.mock import MagicMock, patch
+
+from render_machine.actions.exit_with_error import ExitWithError
+from render_machine.render_types import RenderError
+
+
+def render_context(last_error_message=None):
+    context = MagicMock()
+    context.last_error_message = last_error_message
+    context.frid_context.frid = "2"
+    context.run_state.render_id = "render-id"
+    return context
+
+
+def executed_with(payload, last_error_message=None):
+    context = render_context(last_error_message)
+    with patch("render_machine.actions.exit_with_error.console") as console:
+        outcome, encoded = ExitWithError().execute(context, payload)
+    return console.error.call_args[0][0], outcome, encoded
+
+
+def test_the_failing_action_s_own_message_is_shown():
+    shown, outcome, _ = executed_with("Conformance tests could not be fixed.")
+
+    assert shown == "Conformance tests could not be fixed."
+    assert outcome == ExitWithError.SUCCESSFUL_OUTCOME
+
+
+def test_a_missing_payload_falls_back_to_the_last_error_message():
+    shown, _, _ = executed_with(None, last_error_message="The Unit Tests script has failed.")
+
+    assert shown == "The Unit Tests script has failed."
+
+
+def test_with_nothing_to_report_the_user_still_gets_words():
+    shown, _, _ = executed_with(None)
+
+    assert shown == "Unknown error"
+
+
+def test_an_encoded_error_payload_is_unwrapped_to_its_reason():
+    """The conformance-fix-exhausted path arrives as an encoded RenderError, which used
+    to reach the user as a raw dict repr."""
+    payload = RenderError.encode(message="Could not produce an implementation that passes.").to_payload()
+
+    shown, _, _ = executed_with(payload)
+
+    assert shown == "Could not produce an implementation that passes."
+
+
+def test_the_shown_message_matches_the_encoded_one():
+    """Two sources of truth for the same failure would let the log and the returned
+    error disagree about why a render stopped."""
+    shown, _, encoded = executed_with(None, last_error_message="The Unit Tests script has failed.")
+
+    assert shown == encoded["error"]["message"]