test: improve coverage for invoke, SCXML actions, and async engine

Add 19 tests covering uncovered lines in modified files:
- EventDataWrapper edge cases (no args, __getattr__, name via trigger_data)
- _send_to_parent namelist errors and param expr=None skip
- _send_to_invoke param without expr skip
- invoke_init idempotent behavior
- SCXMLInvoker: on_event exception, non-string content, param location
- Parser: <assign> child XML/text, <invoke> text content
- InvokeManager: send_to_child not found / no on_event, null event
- _stop_child_machine exception handling
- BaseEngine.__del__ cancel_all exception
- Async engine error in before callbacks

Also fix _make_invoker to not hardcode /tmp, and document
coverage report commands in AGENTS.md.

Author: fgmacedo

AGENTS.md

@@ -127,7 +127,19 @@ timeout 120 uv run pytest -n 4
 
 Testes normally run under 60s (~40s on average), so take a closer look if they take longer, it can be a regression.
 
-Coverage is enabled by default.
+Coverage is enabled by default (`--cov` is in `pyproject.toml`'s `addopts`). To generate a
+coverage report to a file, pass `--cov-report` **in addition to** `--cov`:
+
+```bash
+# JSON report (machine-readable, includes missing_lines per file)
+timeout 120 uv run pytest -n auto --cov=statemachine --cov-report=json:cov.json
+
+# Terminal report with missing lines
+timeout 120 uv run pytest -n auto --cov=statemachine --cov-report=term-missing
+```
+
+Note: `--cov=statemachine` is required to activate coverage collection; `--cov-report`
+alone only changes the output format.
 
 ### Testing both sync and async engines
 

tests/test_async.py

@@ -273,6 +273,29 @@ def after_go(self, **kwargs):
     assert sm.configuration == {sm.error_state}
 
 
+@pytest.mark.timeout(5)
+async def test_async_error_on_execution_in_before():
+    """Async engine catches errors in before callbacks with error_on_execution."""
+
+    class SM(StateChart):
+        s1 = State(initial=True)
+        error_state = State(final=True)
+
+        go = s1.to(s1)
+        error_execution = s1.to(error_state)
+
+        def before_go(self, **kwargs):
+            raise RuntimeError("Before boom")
+
+        async def on_enter_state(self, **kwargs):
+            """Async callback to force the async engine."""
+
+    sm = SM()
+    await sm.activate_initial_state()
+    await sm.go()
+    assert sm.configuration == {sm.error_state}
+
+
 @pytest.mark.timeout(5)
 async def test_async_invalid_definition_in_transition_propagates():
     """InvalidDefinition in async transition propagates."""

tests/test_invoke.py

@@ -990,3 +990,83 @@ def on_invoke_loading(self, ctx=None, **kwargs):
         await sm_runner.processing_loop(sm)
 
         assert "loading" in sm.configuration_values
+
+
+class TestInvokeManagerUnit:
+    """Unit tests for InvokeManager methods not exercised by integration tests."""
+
+    def test_send_to_child_not_found(self):
+        """send_to_child returns False when invokeid is not in _active."""
+        from unittest.mock import Mock
+
+        from statemachine.invoke import InvokeManager
+
+        engine = Mock()
+        manager = InvokeManager(engine)
+
+        assert manager.send_to_child("nonexistent", "event") is False
+
+    def test_send_to_child_handler_without_on_event(self):
+        """send_to_child returns False when handler has no on_event."""
+        from unittest.mock import Mock
+
+        from statemachine.invoke import Invocation
+        from statemachine.invoke import InvokeContext
+        from statemachine.invoke import InvokeManager
+
+        engine = Mock()
+        manager = InvokeManager(engine)
+
+        handler = Mock(spec=[])  # no on_event
+        ctx = InvokeContext(invokeid="test_id", state_id="s1", send=Mock(), machine=Mock())
+        inv = Invocation(invokeid="test_id", state_id="s1", ctx=ctx, _handler=handler)
+        manager._active["test_id"] = inv
+
+        assert manager.send_to_child("test_id", "event") is False
+
+    def test_handle_external_event_none_event(self):
+        """handle_external_event returns early when event is None."""
+        from unittest.mock import Mock
+
+        from statemachine.invoke import InvokeManager
+
+        engine = Mock()
+        manager = InvokeManager(engine)
+
+        trigger_data = Mock(event=None)
+        # Should not raise
+        manager.handle_external_event(trigger_data)
+
+
+class TestStopChildMachine:
+    """Tests for _stop_child_machine."""
+
+    def test_stop_child_machine_exception_swallowed(self):
+        """_stop_child_machine swallows exceptions during stop."""
+        from unittest.mock import Mock
+
+        from statemachine.invoke import _stop_child_machine
+
+        child = Mock()
+        child._engine.running = True
+        child._engine._invoke_manager.cancel_all.side_effect = RuntimeError("boom")
+
+        # Should not raise
+        _stop_child_machine(child)
+
+
+class TestEngineDelCleanup:
+    """Test BaseEngine.__del__ cancel_all exception handling."""
+
+    def test_del_swallows_cancel_all_exception(self):
+        """__del__ swallows exceptions from cancel_all."""
+
+        class SM(StateChart):
+            s1 = State(initial=True, final=True)
+
+        sm = SM()
+        engine = sm._engine
+        engine._invoke_manager.cancel_all = lambda: (_ for _ in ()).throw(RuntimeError("boom"))
+
+        # Should not raise
+        engine.__del__()