Tighten fan-out regression + fix CHANGELOG count

PR #102 review caught two issues:

The fan-out regression test's inner subgraph contained only a raising
node, so under the original shared-`latest_state_box` bug no inner
step would have successfully written to the box — the test would
have passed without exercising the leak it was meant to guard. The
inner subgraph now has two nodes: `inner_succeeds` writes
`inner_done=true` (so the descent's _invoke writes inner state to the
box) followed by `inner_raises`. Confirmed by temp-reverting the
descend-omit-`latest_state_box` change and observing the test fail
with the typed-state-mismatch assertion.

CHANGELOG said "three regression tests" but enumerated four (flat,
subgraph, fan-out, parallel-branches). Bumped the count to four.

Author: chris-colinsky

CHANGELOG.md

@@ -28,7 +28,7 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). The
 ### Fixed
 
 - **`InvocationCompletedEvent.final_state` on the failure path now surfaces the partial state at failure point.** Spec §8.4.1 *Resume semantics* requires the failure-path `trace.output` hook to receive "the partial final state captured at the failure point"; the original PR #99 implementation defaulted to `starting_state`, so the hook saw pre-execution state when it should have seen post-execution-up-to-failure state. The engine now tracks the latest post-merge state via a `latest_state_box` on `_InvocationContext`, updated after every successful step and read on the failure path. Success-path behavior unchanged.
-- **`latest_state_box` is per-context, not shared across subgraph descents.** Unlike the sibling `final_node_box` (which shares by reference because the spec wants the innermost failing node's name — the real culprit), `latest_state_box` must isolate per level so the outermost Langfuse trace receives outer-state-typed values. Without the isolation, a subgraph-internal step's inner-typed state would leak up to the outer trace.output hook, breaking the hook's typed contract. Each subgraph / fan-out instance / parallel-branches branch gets its own fresh box. Pinned by three regression tests covering flat, subgraph, fan-out, and parallel-branches failure paths.
+- **`latest_state_box` is per-context, not shared across subgraph descents.** Unlike the sibling `final_node_box` (which shares by reference because the spec wants the innermost failing node's name — the real culprit), `latest_state_box` must isolate per level so the outermost Langfuse trace receives outer-state-typed values. Without the isolation, a subgraph-internal step's inner-typed state would leak up to the outer trace.output hook, breaking the hook's typed contract. Each subgraph / fan-out instance / parallel-branches branch gets its own fresh box. Pinned by four regression tests covering flat, subgraph, fan-out, and parallel-branches failure paths.
 
 ### Notes
 

tests/unit/test_observability_langfuse.py

@@ -926,10 +926,21 @@ class _FanOutOuterState(State):
 class _FanOutInnerState(State):
     item: int = 0
     out: int = 0
+    inner_done: bool = False
+
+
+async def _fan_out_inner_succeeds(_s: _FanOutInnerState) -> dict[str, Any]:
+    # Successful inner step — writes ``inner_done=true`` to the
+    # instance's _invoke ``state`` local AND to the shared
+    # ``latest_state_box`` (per-context, so it lands on the instance's
+    # OWN box).  Under the original shared-box bug this write would
+    # leak into the outer box; under the per-context design it stays
+    # isolated to the instance.
+    return {"inner_done": True}
 
 
 async def _fan_out_inner_raises(_s: _FanOutInnerState) -> dict[str, Any]:
-    raise RuntimeError("fan_out inner_node boom")
+    raise RuntimeError("fan_out inner_raise boom")
 
 
 async def test_failure_path_final_state_is_outer_type_when_fan_out_inner_raises() -> None:
@@ -941,11 +952,22 @@ async def test_failure_path_final_state_is_outer_type_when_fan_out_inner_raises(
     # raises, the outermost ``invoke()``'s finally-block reads the
     # OUTER box — which holds outer state from ``outer_a``'s successful
     # completion, not the inner instance state.
+    #
+    # The inner subgraph has TWO inner nodes: ``inner_succeeds`` writes
+    # inner state to the instance's box, then ``inner_raises``
+    # propagates.  Under the original shared-box bug, the box would
+    # end with ``_FanOutInnerState(inner_done=true)`` and the outer
+    # hook would receive that inner-typed value.  The two-node shape
+    # is load-bearing — a single-node "always raise" subgraph would
+    # not exercise the leak because no successful inner step would
+    # write to the box.
     inner_graph = (
         GraphBuilder(_FanOutInnerState)
-        .add_node("inner_raise", _fan_out_inner_raises)
-        .add_edge("inner_raise", END)
-        .set_entry("inner_raise")
+        .add_node("inner_succeeds", _fan_out_inner_succeeds)
+        .add_node("inner_raises", _fan_out_inner_raises)
+        .add_edge("inner_succeeds", "inner_raises")
+        .add_edge("inner_raises", END)
+        .set_entry("inner_succeeds")
         .compile()
     )