feat(poker): auto-fill hero's stack from the last stack log

When a hand doesn't state hero's stack, default it to current_stack() (his last
logged stack) — the system already knows it from the stack log even when he doesn't
restate it every hand. record_hand._fill_hero_stack sets the hero player's stack and
marks stack_inferred=True (honest about stated vs inferred); a stack given in the
hand text always wins, and observed hands get nothing. 3 tests; suite 226 green.

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

lyra/poker.py

@@ -931,15 +931,42 @@ def _recent_duplicate_hand(parsed: dict, session_id: int | None, window_sec: int
     return int(row["id"]) if row else None
 
 
+def _fill_hero_stack(parsed: dict, session_id: int | None) -> dict:
+    """Default hero's starting stack to the last logged stack (current_stack) when the hand
+    didn't state one — the system already knows his stack from the stack log even when he
+    doesn't restate it every hand. Only fills a genuinely missing value; a stack he gave in
+    the hand text always wins. Marks the hero player stack_inferred so it's honest about it."""
+    if not isinstance(parsed, dict) or parsed.get("hero_involved", True) is False:
+        return parsed
+    hero_pos = parsed.get("hero_pos")
+    if not hero_pos:
+        return parsed
+    players = parsed.setdefault("players", [])
+    hero = next((pl for pl in players if pl.get("hero") or pl.get("pos") == hero_pos), None)
+    if hero and hero.get("stack") not in (None, 0):
+        return parsed  # he stated a stack — never override it
+    stack = current_stack(session_id)
+    if stack is None:
+        return parsed  # nothing logged yet to borrow
+    if hero is None:
+        hero = {"pos": hero_pos}
+        players.append(hero)
+    hero["stack"] = stack
+    hero["stack_inferred"] = True
+    return parsed
+
+
 def record_hand(shorthand: str, session_id: int | None = None, stakes: str | None = None,
                 tag: str | None = None, lesson: str | None = None,
                 backend: str | None = None) -> dict:
     """Parse shorthand -> structured hand -> store. Returns {id, parsed} (id None on parse fail).
     Idempotent: if this exact hand was just logged for the session (double turn execution),
-    returns the existing one instead of inserting a duplicate."""
+    returns the existing one instead of inserting a duplicate. Hero's stack is auto-filled
+    from the last stack log when he didn't restate it."""
     parsed = parse_hand(shorthand, stakes=stakes, backend=backend)
     if not parsed:
         return {"id": None, "parsed": None}
+    parsed = _fill_hero_stack(parsed, session_id)
     dup = _recent_duplicate_hand(parsed, session_id)
     if dup is not None:
         return {"id": dup, "parsed": parsed, "linked": 0, "deduped": True}