Fix current_state.latest_observation sort to use true recency

Fourth dogfood-surfaced bug. Within a single runtime session, multiple
record_observation calls inherit the same episode's event_at, so the
previous step_index-only sort collapsed their order to insertion order
and returned the *oldest* write as "latest_observation" — the opposite
of what the field promises.

Sort now uses (event_at, created_at, step_index) with reverse=True:

- event_at is the primary semantic signal (when the observed event
  happened) and wins when it genuinely differs across observations.
- created_at varies per write regardless of episode reuse, so it
  breaks event_at ties correctly within a session.
- step_index remains the final tiebreak so trajectory-based ingestion
  (where step_index IS the authoritative ordering) keeps working.

Regression test seeds three record_observation calls with 10ms spacing
and asserts the third one surfaces as latest_observation. 14 tests
pass (was 13) — the full pass now covers all four dogfood findings.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: CharlieGreenman

state_trace/memory.py

@@ -345,9 +345,20 @@ def _step(node: Node) -> int:
             value = node.metadata.get("step_index")
             return int(value) if value is not None else -1
 
+        def _recency_key(node: Node) -> tuple:
+            # Most-recent-first. Primary sort: event_at (the semantic "when
+            # did the thing happen"). Tiebreak on created_at — dogfood
+            # finding: within one runtime session, multiple record_observation
+            # calls share an episode's event_at stamp, so event_at alone ties
+            # and falls back to insertion order. created_at varies per write
+            # and breaks those ties correctly. Final tiebreak on step_index
+            # so trajectory-based ingestion preserves step ordering.
+            event_at = node.event_at or node.created_at
+            return (event_at, node.created_at, _step(node))
+
         task_nodes.sort(key=lambda node: (node.importance, _step(node)), reverse=True)
-        observation_nodes.sort(key=_step, reverse=True)
-        decision_nodes.sort(key=_step, reverse=True)
+        observation_nodes.sort(key=_recency_key, reverse=True)
+        decision_nodes.sort(key=_recency_key, reverse=True)
 
         active_files = sorted(
             file_nodes.values(),

tests/test_temporal_memory.py

@@ -326,6 +326,30 @@ def test_retrieve_brief_preserves_load_bearing_detail_in_top_evidence() -> None:
     )
 
 
+def test_current_state_latest_observation_is_truly_most_recent() -> None:
+    """Dogfood regression: within one runtime session, multiple record_observation
+    calls share step_index=0. Before the fix, current_state sorted observations
+    by step_index only and returned insertion order as 'latest', so the newest
+    write wasn't the one surfaced. Now sort is by event_at -> most recent wins."""
+    import time
+    engine = MemoryEngine(capacity_limit=128.0)
+    ctx = {"session": "recency-session", "goal": "verify recency"}
+    engine.store("Verify ordering", {"type": "task", "importance": 0.9, **ctx})
+    engine.record_observation("First observation", {**ctx, "status": "info"})
+    time.sleep(0.01)  # ensure event_at differs
+    engine.record_observation("Second observation", {**ctx, "status": "info"})
+    time.sleep(0.01)
+    engine.record_observation("Third observation — newest", {**ctx, "status": "info"})
+
+    state = engine.current_state(session="recency-session")
+
+    assert state["latest_observation"] is not None
+    assert state["latest_observation"]["content"] == "Third observation — newest", (
+        f"latest_observation should be the most recent write, not the first; "
+        f"got: {state['latest_observation']['content']!r}"
+    )
+
+
 def test_failed_hypotheses_surfaces_rejected_angle_observations() -> None:
     """Dogfood regression: concluded dead-ends recorded as status=info with
     rejected_angle=True should surface from failed_hypotheses with reason