feat: recall claims the richest memory, not the oldest

should_recall now returns the longest unclaimed memory (ties -> oldest)
so Hollow reclaims a vivid, detailed memory instead of a thin one like
'had a grandmother'. Detail is what lands the recall 'wow'. 33 tests.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

memory.py

@@ -39,11 +39,16 @@ def should_recall(state: dict) -> tuple[bool, str | None]:
     if not unclaimed:
         return False, None
 
+    # Claim the richest (longest, most evocative) memory, not the oldest —
+    # a thin "had a grandmother" makes a weak recall; detail lands the "wow".
+    # Ties resolve to the oldest (max keeps the first of equal-length items).
+    richest = max(unclaimed, key=len)
+
     last = state.get("last_recall_turn")
     if last is None:
-        return True, unclaimed[0]
+        return True, richest
 
     if state["turn"] - last >= 3:
-        return True, unclaimed[0]
+        return True, richest
 
     return False, None

tests/test_memory.py

@@ -112,7 +112,22 @@ class TestShouldRecall:
         assert fired is True
         assert mem == "has a dog named Nala"
 
-    def test_first_recall_returns_oldest_unclaimed(self):
+    def test_recall_returns_richest_unclaimed(self):
+        state = self._state(
+            affinity=55,
+            treasure=[
+                "had a grandmother",
+                "had a red bicycle I loved more than anything, stolen, cried for days",
+                "kept bees",
+            ],
+            claimed=[],
+            last_recall_turn=None,
+        )
+        fired, mem = should_recall(state)
+        assert fired is True
+        assert mem == "had a red bicycle I loved more than anything, stolen, cried for days"
+
+    def test_recall_tie_breaks_to_oldest_when_equal_length(self):
         state = self._state(
             affinity=55,
             treasure=["memory A", "memory B"],