docs: spec for poker message-type prompts + dumb capture

Two-track poker interaction: dumb data capture (stack/buyin/cashout)
that bypasses the LLM, plus a message-type classifier that injects
type-specific prompt fragments (HAND/STATUS/MENTAL/LOG/CHAT) in place
of the one broad poker card. Kills the false tilt-reads and the
coaching-essay-on-every-turn behavior. Includes the iOS-PWA bottom
safe-area fix and the 2nd input box from Brian's screenshot.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01G796GsLCvJQKVN7hwV2cDx

docs/DECISION_LOG.md

@@ -1,48 +0,0 @@
-# Decision log — Decide mode's learning layer
-
-Built overnight on `feat/decision-log`. This is the **data layer + tools only**. The
-prompt/mode wiring (the taste part) is left for you on purpose — no persona/card edits
-were made.
-
-## The idea
-
-Decide mode is currently a one-shot tie-breaker. The learning layer gives it memory:
-log the call Brian actually makes, record how it turned out, and recall similar past
-calls so a new recommendation leans on his own track record instead of generic advice.
-
-Lifecycle: **log** (when the call is made) → **resolve** (later, with the outcome) →
-**recall** (next time something similar comes up).
-
-## What's built
-
-**Storage** (`lyra/memory.py`):
-- `decisions` table — situation, options, choice, rationale, confidence (1-5), tags,
-  embedding (over situation+choice), outcome, outcome_rating (-1/0/+1), resolved_at.
-- `Decision` dataclass (with a `.resolved` property).
-- `log_decision(...) -> id`, `resolve_decision(id, outcome, rating) -> bool`,
-  `get_decision(id)`, `list_decisions(limit, open_only)`,
-  `recall_decisions(query, k)` (cosine over embeddings, each hit carries `.score`).
-- Embedding failures never block a log (blob just stays NULL).
-
-**Tools** (`lyra/tools.py`) — handlers + specs, wired into `dispatch`:
-- `log_decision` (situation, choice, options?, rationale?, confidence?, tags?)
-- `resolve_decision` (decision_id, outcome, rating?)
-- `recall_decisions` (query, k?) — returns past calls with their verdicts
-
-**Tests** (`tests/test_decisions.py`) — 9, covering roundtrip, resolve, open-only
-filtering, similarity ranking, and all three tool handlers. Full suite green, ruff clean.
-
-## What's left for you (the wiring)
-
-1. **Allow-list** — add the three tools to `_DECIDE_TOOLS` in `lyra/modes.py`
-   (and decide whether `recall_decisions` also belongs in Study). One-liner, but it's
-   the gate that lets her actually call them.
-2. **Decide card guidance** — tell her *when* to use them: recall similar decisions
-   before recommending, log once Brian commits to a call, and circle back to resolve
-   open ones. This is the part I didn't want to touch without you (no bandaids).
-3. **Optional surfacing** — open/unresolved decisions are a natural thing for her to
-   raise (thought loop / ping), and a small UI panel could list them. Not built.
-4. **Optional auto-prompt to resolve** — the dream loop could notice decisions that
-   have been open a while and nudge for an outcome.
-
-Nothing here changes behavior until step 1 — the tools exist but no mode offers them.

docs/HAND_HISTORY.md

@@ -0,0 +1,72 @@
+# Hand-history contract (Lyra → RTO)
+
+The canonical structured shape for a poker hand. **Lyra owns hands** — it produces this
+shape (LLM parser today; the tap recorder natively, going forward), stores it, replays it
+in the viewer, and exports it. **RTO consumes it** over HTTP and never reaches into Lyra.
+
+Ownership rule: whoever owns the data owns the tools that produce it. Lyra owns the hand
+DB, the viewer, and the copilot loop, so hand capture lives here. RTO is a pure engine.
+
+Coupling: **one arrow, Lyra → RTO, HTTP only.** RTO is a standalone service (solve /
+exploit / estimate); Lyra POSTs to it when it wants analysis. No shared package, no shared
+DB, no shared UI components. If RTO is down, Lyra skips analysis and nothing breaks.
+
+## Schema (`schema_version: 1`)
+
+```jsonc
+{
+  "schema_version": 1,
+  "game": "NLH",                     // NLH | PLO | ...
+  "stakes": "1/3",                   // or null
+  "hero_pos": "BTN",                 // one of POSITIONS
+  "hero_cards": ["Ah", "Kh"],        // convenience mirror of the hero's players[].cards
+  "players": [                       // every player in the hand, incl. hero
+    {"pos": "BTN", "stack": 300, "name": "Hero", "cards": ["Ah","Kh"], "hero": true},
+    {"pos": "BB",  "stack": 250, "name": "Sal",  "cards": null}        // cards: null unless shown
+  ],
+  "actions": [                       // one flat chronological list across all streets
+    {"street": "preflop", "pos": "BTN", "action": "raise", "amount": 15},
+    {"street": "flop", "board": ["7d","2c","5h"]},   // a street begins with its board reveal
+    {"street": "flop", "pos": "BB", "action": "check"}
+  ],
+  "board": ["7d","2c","5h"],         // full final board, 0–5 cards
+  "result": {"pot": 40, "hero_net": 25, "summary": "one line"},
+  "completeness": {"cards": true, "board": true, "actions": true}
+}
+```
+
+### Conventions (load-bearing)
+
+- **Cards are lists of 2-char tokens**, `RankSuit`: rank in `23456789TJQKA` (ten = `T`),
+  suit in `c d h s` (lowercase). E.g. `["As","5d","2c"]`. RTO maps each token via
+  `pokercore.parse_card`. *(Chosen over space-joined strings: unambiguous, no re-splitting,
+  and it's what Lyra already stores + what the viewer reads.)*
+- **Unknown cards are kept, not dropped:** `"Ax"` = known rank / unknown suit, `"x"` =
+  fully unknown card. The LLM parser emits these when Brian didn't state suits. The tap
+  recorder won't — it captures complete cards by construction — so `"x"` is an
+  import/parser-only concern.
+- **`completeness`** tells a consumer what's safe to use: `cards`/`board` are `true` only
+  when every relevant card is fully specified (no `"x"`). RTO uses `false`-card hands for
+  positions/frequencies/pairs and skips suit-dependent math (flushes).
+- **Hero appears in `players[]`** with `"hero": true` and is findable via `pos == hero_pos`.
+  `hero_cards` is a mirror for the viewer; `players[].cards` is the source of truth.
+- **Positions:** `UTG UTG1 UTG2 MP LJ HJ CO BTN SB BB`.
+- **Actions:** `post fold check call bet raise allin`. `amount` is a plain number (no `$`),
+  null for non-sized actions (fold/check). Street boards appear as `{street, board}` entries.
+- **Streets:** `preflop flop turn river`.
+
+`lyra/poker.py:normalize_structured()` is the single function that guarantees this shape.
+It runs on store and on read, and is idempotent.
+
+## Transport (HTTP, Lyra serves on :7078)
+
+- `GET /hands/data?limit=N` → `{ "hands": [ {id, position, hole_cards, board, result, tag,
+  at, lesson, venue, stakes, has_structured}, ... ] }` — flat list for browsing. Use
+  `has_structured` to pick which hands have a replayable body worth fetching.
+- `GET /hand/{id}/data` → the full hand row; `structured` is the object above (or `null`
+  for a flat quick-log that hasn't been reconstructed).
+
+RTO's "Lyra bridge" (its `docs/estimator-design.md`, Phase B) walks `structured.actions`
+to classify each villain decision into `checked_to` / `facing_bet` / `facing_raise`, and
+uses shown `cards` + that street's `board` for board-relative categories. Everything that
+walk needs is in the schema above.

docs/superpowers/specs/2026-06-28-poker-mode-prompts-design.md

@@ -0,0 +1,115 @@
+# Poker mode: message-type-specific prompts + dumb capture
+
+- **Date:** 2026-06-28
+- **Status:** Draft for review
+- **Scope:** Poker (`poker_cash`) mode only. This is the template; the same pattern will later extend to Build/Explore/Study/Decide in a separate pass.
+
+## Problem
+
+In poker mode Lyra routes correctly but her replies are generic — "stringing poker words together." Evidence from the 2026-06-27 (Meadows) and 2026-06-28 (Wheeling) sessions in chat `sess-dff2s91c`:
+
+- **Every turn is a coaching essay, including pure data.** A stack update (`Stack=$685`) draws 4–6 sentences of momentum filler ("keep that momentum rolling," "you've got this"). Bare facts don't need a brain.
+- **She projects tilt/fatigue onto neutral facts.** "Table broke, it's 11:50pm" → three replies about "late-night fatigue-driven decisions… mental reset." Brian had to say *"I'm not upset… you seem to be reading me as tilted."* Cause: the `_route` mood nudge (`lyra/mind.py:328`) firing on non-mood messages.
+- **She doesn't reason about bet intent.** On a hand where Brian flopped bottom set, turned a full house, value bet $40 and got 88 to fold, she said *"his fold… shows the power of representing something stronger… well executed."* That was a **value bet that got no value** — money left on the table — not a successful rep. She pattern-matched "bet → fold → good."
+- **She never calls `analyze_spot`; she eyeballs.** The 77 multiway spot got *"a disciplined fold might have been the better path"* — pure hedge, no math, violating the persona's "never eyeball poker math" rule.
+- **Even her best reply leaks bad poker logic.** The sharp Connie read included "limp-checking in position" — contradictory nonsense — proving "sounds sharp" ≠ "is correct."
+
+Root cause: one large per-turn card (`_CASH_CARD`, `lyra/modes.py:66`) describes **traits** ("be decisive," "be present"). The model satisfies trait language with safe, flattering abstraction. Pure-data turns shouldn't reach the model at all; judgment turns need concrete response contracts, not adjectives.
+
+## Goals
+
+1. Pure data entry (stack, buy-in, cash-out) never touches the LLM.
+2. Conversational turns get a **message-type-specific** prompt instead of one broad card.
+3. Kill the false tilt/fatigue reads.
+4. On hands, reason about **bet intent** and lean on `analyze_spot` — flag missed value, value-owning, and sizing rather than reflexively praising.
+5. Fix the iOS-PWA bottom safe-area gap surfaced in testing.
+
+## Non-goals
+
+- Rewriting the other five modes (separate pass).
+- Changing the tool handlers themselves (`poker.log_stack`, etc. already exist and are LLM-independent).
+- An LLM-based classifier in v1 (the design leaves the seam for it; v1 ships heuristics).
+- Itemized buy-in history (buy-ins remain a single `buy_in_total`).
+
+## Architecture
+
+Split poker input by whether it needs judgment.
+
+- **Track 1 — dumb capture:** pure data → direct HTTP endpoint → tool handler. No prompt, no reply.
+- **Track 2 — conversational:** anything needing a brain → a classifier tags the message type → a type-specific prompt fragment is injected in place of the giant card.
+- **PWA fix:** correct the bottom safe-area inset.
+
+### Deliverable 1 — Track 1: dumb capture (no LLM)
+
+**Backend (new endpoints in `lyra/web/server.py`).** Today the *only* write path for a stack/buy-in is chat → tool-calling; no direct endpoint exists. Add:
+
+- `POST /session/stack` → `poker.log_stack(amount)` → returns updated `stack_state()`. Server stamps the time.
+- `POST /session/buyin` → `poker.add_buyin(amount)` → returns new `buy_in_total`.
+- Cash-out reuses the existing `PATCH /session/{id}` with `{cash_out}` (already recomputes `net`).
+
+Both resolve the live session via `poker._resolve(None)` and return `{"ok": ..., "stack": ...}`. On "no live session" return a clear error the UI can show.
+
+**Frontend — the 2nd input box (`lyra/web/static/index.html`).** A slim quick-capture row **below the message input, above the bottom nav icons**. Behavior:
+
+- Type a number (e.g. `685`) → `POST /session/stack` → on success, append a one-line confirmation to the **Live Log** (`$685 logged · 11:34pm`) and update the HUD. **No chat message, no LLM call, main message box untouched.**
+- Scope: **stack only** in v1. Buy-in and cash-out live on the Session HUD widget below.
+- Empty/non-numeric input is ignored (or shows inline hint). Decimal and `$`-prefixed input tolerated (`$685`, `685`).
+
+**Frontend — HUD widget (`lyra/web/static/session.html`).** In the Stack card (`session.html:280`), mirroring the existing `saveEdit()` PATCH pattern (`session.html:192`): a stack field (`POST /session/stack`), a buy-in field (`POST /session/buyin`), and a cash-out field (existing PATCH). Each updates the sparkline on success.
+
+### Deliverable 2 — Track 2: classifier + type fragments
+
+**Classifier (`lyra/poker_classify.py`, new).** A function `classify(message: str) -> str` returning one of `HAND | STATUS | MENTAL | LOG | CHAT`. v1 is heuristic; the signature is the swappable seam — an LLM/MI50 implementation can replace the body later with no other changes.
+
+Heuristic signals (first match wins, in priority order):
+
+1. **HAND** — card-token regex (`\b[2-9TJQKA][shdc]\b` appearing ≥2×), or position tokens (UTG/MP/HJ/CO/BTN/SB/BB/"button"/"hijack"), or street words (flop/turn/river) combined with betting verbs (bet/raise/call/fold/check/shove/limp).
+2. **MENTAL** — first-person feeling: "I feel", "I'm tilted/steaming/fried/tired/frustrated/confident", "in my head", "mental", "leak", "on tilt".
+3. **STATUS** — time/venue/logistics with no cards: "table broke", "new table", "waiting for a seat", "seat opened", clock times, venue names.
+4. **LOG** — prose money/result that slipped past the 2nd box: "I'm at 350", "stack is", "out for", "cashed", "rebought" with a number.
+5. **CHAT** — default fallback (questions, open talk).
+
+Ambiguous → `CHAT` (safe full-voice default).
+
+**Pipeline integration (`lyra/mind.py`).** Add a `_classify` step to `PIPELINE` (after `_route`, before `_compose`) that sets `ctx.msg_type` when `ctx.mode.key == "poker_cash"`. In `build_messages` (`mind.py:137`), when in poker mode, inject the **type fragment** in the seat currently held by `mode.card` (`mind.py:152`) instead of the whole `_CASH_CARD`. Non-poker modes are unchanged.
+
+**Fragment registry (new `lyra/poker_prompts.py`).** `POKER_FRAGMENTS: dict[str, str]` keyed by type. Each fragment is short and concrete (rules + response shape), not trait language. Persona guardrails ("never eyeball math," "don't invent reads") stay sourced from `personas/lyra.md` via `_persona_block`.
+
+Response contracts:
+
+- **HAND.** Steps, in order: (1) log it (`record_hand` preferred, or `log_hand`); (2) if the decision is close or equity matters, call `analyze_spot` — do **not** eyeball; (3) reason about **bet intent** — for each meaningful bet, name what it was for (value / bluff / protection) and whether it achieved that (a fold to a value bet = value lost — flag it; a call of a bluff = bluff failed); (4) name leaks plainly (value-owning, missed value, bad sizing); (5) one clear opinion. **No reflexive praise** — do not open with "nice hand." If a named villain is referenced, call `player_profile`/`get_villain_file` first; never invent a read. Talk in prose, not a listicle. Seed with 2 exemplars (below).
+- **STATUS.** 1–2 sentences. Acknowledge, log a stack only if a bare number is present, then stop. **No coaching. No tilt/fatigue reads.**
+- **MENTAL.** Full presence, real voice, an actual point of view. (This register already works — preserve it.)
+- **LOG.** One line. `$317 logged.` Nothing else.
+- **CHAT.** Full voice, a real opinion, no filler sign-offs.
+
+**HAND exemplars** (embedded in the fragment):
+
+> *Brian:* "Flopped bottom set with 22, turned a full house, bet $40 on the river, he folded 88."
+> *Lyra:* "That's a value bet that got no value — 88 was never folding to a smaller stab. $40 into that pot was too much; ~$20–25 gets called by the over-pair and the worse two-pairs. The hand's a monster, the leak is the sizing."
+
+> *Brian:* "77 in a multiway pot, flop 4h5c3c, HJ bets 75, BTN shoves 74, I call. Turn/river check through, HJ wins with 64."
+> *Lyra:* "Against a bet and a shove on 4-5-3 you're drawing thin — sets, two pair, and the made wheel are all ahead, and you block almost none of it. The stack-depth logic (he only had ~150 behind) is real, but that's a reason to fold and wait, not to call off light. This is the value-owning spot you flagged yourself."
+
+**Pipeline fixes:**
+
+- Remove/gate the `_route` mood nudge (`mind.py:328`) so a steady→"steady" / up→"hype" note is **not** appended on non-MENTAL messages. Mental-game register comes only from the MENTAL fragment.
+- Trim the always-on mode-menu note (`mind.py:77`) inside poker mode — it dilutes every turn.
+
+### Deliverable 3 — PWA bottom safe-area fix
+
+The band below the nav icons is an iOS-PWA safe-area issue (likely `100vh` not accounting for `env(safe-area-inset-bottom)` / the home indicator). Fix the layout container and bottom nav in the web CSS so the app fills the viewport with the icons seated above the home indicator. Use the `building-ios-pwas` skill at implementation time.
+
+## Testing / verification
+
+- **Classifier unit tests:** feed the real user turns from both transcripts and assert the expected type (e.g. "Stack is at $373" → LOG/handled by box, "Button straddle… I limp UTG with 22…" → HAND, "table broke, it's 11:50pm" → STATUS, "I feel like I'm being mean when I raise" → MENTAL).
+- **Endpoint tests:** `POST /session/stack` / `/session/buyin` against a live test session; assert the row is written, time stamped, and `stack_state()` updates; assert a clean error when no live session.
+- **Transcript replay (eyeball eval):** run yesterday's + today's user turns through the new classifier + fragments and compare replies to the logged mush — confirm stack updates produce no essay, the $40 hand is flagged as missed value, and STATUS turns carry no tilt-reading.
+- **PWA:** verify on the iOS PWA that the gap is gone and the new input box sits above the nav with the keyboard open.
+
+## Out of scope / future
+
+- LLM classifier behind the same interface (if heuristics prove brittle).
+- Extending message-type fragments to the other five modes.
+- Itemized buy-in history / per-table stack series.
+- Buy-in/cash-out in the chat-page 2nd box (HUD only for v1).

lyra/clock.py

@@ -9,20 +9,39 @@ a long silence *means* to her is left to her own reflection, not prescribed here
 from __future__ import annotations
 
 from datetime import datetime, timezone
+from zoneinfo import ZoneInfo
+
+from lyra import config
 
 
 def now() -> datetime:
     return datetime.now(timezone.utc)
 
 
+def _local_tz() -> ZoneInfo | timezone:
+    """Brian's configured local zone (falls back to UTC if it can't be loaded)."""
+    try:
+        return ZoneInfo(config.load().timezone)
+    except Exception:
+        return timezone.utc
+
+
 def _parse(iso: str) -> datetime:
     dt = datetime.fromisoformat(iso)
     return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
 
 
+def short(iso_or_dt: str | datetime | None = None) -> str:
+    """Local time-of-day like '10:45pm', for timeline rows."""
+    dt = _parse(iso_or_dt) if isinstance(iso_or_dt, str) else (iso_or_dt or now())
+    return dt.astimezone(_local_tz()).strftime("%-I:%M%p").lower()
+
+
 def stamp(dt: datetime | None = None) -> str:
-    """Wall-clock stamp, e.g. 'Wednesday, 17 Jun 2026, 01:50 UTC'."""
-    return (dt or now()).strftime("%A, %d %b %Y, %H:%M UTC")
+    """Wall-clock stamp in Brian's local timezone, e.g.
+    'Friday, 27 Jun 2026, 01:50 EDT'. Times are stored UTC; this is what she *reads*,
+    so 'what time is it' answers in his time, not UTC."""
+    return (dt or now()).astimezone(_local_tz()).strftime("%A, %d %b %Y, %H:%M %Z")
 
 
 def gap_seconds(since_iso: str | None, ref: datetime | None = None) -> float | None:

lyra/llm.py

@@ -2,11 +2,13 @@
 from __future__ import annotations
 
 import json
+import time
 from typing import Iterator, Literal, TypedDict
 
 import httpx
 from openai import OpenAI
 
+from lyra import logbus
 from lyra.config import load
 
 
@@ -18,30 +20,54 @@ class Message(TypedDict):
 Backend = Literal["local", "cloud", "mi50"]
 
 
+def _approx_tok(messages: list) -> int:
+    """Rough prompt size (chars/4) — enough to see what's loading a backend."""
+    total = 0
+    for m in messages or []:
+        if isinstance(m, dict) and isinstance(m.get("content"), str):
+            total += len(m["content"])
+    return total // 4
+
+
+def _resolved_model(cfg, backend: Backend, model: str | None) -> str:
+    if backend == "cloud":
+        return model or cfg.cloud_model
+    if backend == "mi50":
+        return model or cfg.mi50_model
+    return model or cfg.local_model
+
+
 def complete(messages: list[Message], backend: Backend = "local", model: str | None = None) -> str:
     """Generate a completion. `model` overrides the backend's default model
     (used so live chat can run a stronger cloud model than bulk consolidation)."""
     cfg = load()
+    mdl = _resolved_model(cfg, backend, model)
+    logbus.log("info", "llm call", kind="complete", backend=backend, model=mdl, tok=_approx_tok(messages))
+    t0 = time.monotonic()
+
     if backend == "cloud":
         if not cfg.openai_api_key:
             raise RuntimeError("OPENAI_API_KEY is not set")
         client = OpenAI(api_key=cfg.openai_api_key)
-        resp = client.chat.completions.create(model=model or cfg.cloud_model, messages=messages)
-        return resp.choices[0].message.content or ""
-
-    if backend == "mi50":
+        resp = client.chat.completions.create(model=mdl, messages=messages)
+        out = resp.choices[0].message.content or ""
+    elif backend == "mi50":
         # MI50 box runs an OpenAI-compatible llama.cpp server; key is unused.
         client = OpenAI(api_key="not-needed", base_url=cfg.mi50_base_url)
-        resp = client.chat.completions.create(model=model or cfg.mi50_model, messages=messages)
-        return resp.choices[0].message.content or ""
-
+        resp = client.chat.completions.create(model=mdl, messages=messages)
+        out = resp.choices[0].message.content or ""
+    else:
         resp = httpx.post(
             f"{cfg.local_base_url}/api/chat",
-        json={"model": model or cfg.local_model, "messages": messages, "stream": False},
+            json={"model": mdl, "messages": messages, "stream": False},
             timeout=120,
         )
         resp.raise_for_status()
-    return resp.json()["message"]["content"]
+        out = resp.json()["message"]["content"]
+
+    logbus.log("info", "llm done", kind="complete", backend=backend,
+               ms=int((time.monotonic() - t0) * 1000), out=len(out))
+    return out
 
 
 def chat_call(
@@ -68,6 +94,8 @@ def chat_call(
         kwargs: dict = {"model": mdl, "messages": messages}
         if tools:
             kwargs["tools"] = tools
+        logbus.log("info", "llm call", kind="chat", backend=backend, model=mdl, tok=_approx_tok(messages))
+        t0 = time.monotonic()
         msg = client.chat.completions.create(**kwargs).choices[0].message
         tcs = None
         if getattr(msg, "tool_calls", None):
@@ -75,6 +103,9 @@ def chat_call(
                 {"id": tc.id, "name": tc.function.name, "arguments": tc.function.arguments}
                 for tc in msg.tool_calls
             ]
+        logbus.log("info", "llm done", kind="chat", backend=backend,
+                   ms=int((time.monotonic() - t0) * 1000), out=len(msg.content or ""),
+                   tools=[t["name"] for t in tcs] if tcs else None)
         return msg.model_dump(), tcs
 
     # local (Ollama): no tool-calling here — return plain content.
@@ -105,6 +136,8 @@ def chat_call_stream(
         kwargs: dict = {"model": mdl, "messages": messages, "stream": True}
         if tools:
             kwargs["tools"] = tools
+        logbus.log("info", "llm call", kind="chat-stream", backend=backend, model=mdl, tok=_approx_tok(messages))
+        t0 = time.monotonic()
         parts: list[str] = []
         frags: dict[int, dict] = {}  # tool-call fragments accumulated by index
         for chunk in client.chat.completions.create(**kwargs):
@@ -123,6 +156,9 @@ def chat_call_stream(
                 if tc.function and tc.function.arguments:
                     slot["arguments"] += tc.function.arguments
         content = "".join(parts)
+        logbus.log("info", "llm done", kind="chat-stream", backend=backend,
+                   ms=int((time.monotonic() - t0) * 1000), out=len(content),
+                   tools=[frags[i]["name"] for i in sorted(frags)] if frags else None)
         if frags:
             calls = [frags[i] for i in sorted(frags)]
             assistant = {

lyra/memory.py

@@ -115,26 +115,6 @@ CREATE TABLE IF NOT EXISTS ratings (
     note TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_ratings_created ON ratings(created_at);
-
--- Decisions Lyra helped Brian make (Decide mode's learning layer). Logged when the
--- call is made; resolved later with how it actually turned out; recalled by semantic
--- similarity so a new call can lean on how similar ones went. embedding covers the
--- situation + choice. Resolved rows (with an outcome) are the signal worth recalling.
-CREATE TABLE IF NOT EXISTS decisions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    created_at TEXT NOT NULL,
-    situation TEXT NOT NULL,    -- what was being decided
-    options TEXT,               -- the alternatives weighed (free text / newline list)
-    choice TEXT NOT NULL,       -- the call that was made
-    rationale TEXT,             -- why
-    confidence INTEGER,         -- 1-5, how sure at the time (nullable)
-    tags TEXT,                  -- domain: poker | life | build | ... (comma-separated)
-    embedding BLOB,
-    outcome TEXT,               -- filled in on resolve: what actually happened
-    outcome_rating INTEGER,     -- -1 bad / 0 mixed / +1 good (nullable until resolved)
-    resolved_at TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_decisions_created ON decisions(created_at);
 """
 
 _conn: sqlite3.Connection | None = None
@@ -204,26 +184,6 @@ class Era:
     score: float | None = None
 
 
-@dataclass
-class Decision:
-    id: int
-    created_at: str
-    situation: str
-    choice: str
-    options: str | None = None
-    rationale: str | None = None
-    confidence: int | None = None
-    tags: str | None = None
-    outcome: str | None = None
-    outcome_rating: int | None = None
-    resolved_at: str | None = None
-    score: float | None = None
-
-    @property
-    def resolved(self) -> bool:
-        return self.resolved_at is not None
-
-
 def _to_blob(vec: list[float]) -> bytes:
     return np.asarray(vec, dtype=np.float32).tobytes()
 
@@ -685,87 +645,6 @@ def backfill_journal_embeddings(limit: int | None = None) -> int:
     return n
 
 
-# --- decisions (Decide mode's learning layer) ---------------------------------
-
-def _row_to_decision(r: sqlite3.Row) -> Decision:
-    return Decision(
-        id=r["id"], created_at=r["created_at"], situation=r["situation"],
-        choice=r["choice"], options=r["options"], rationale=r["rationale"],
-        confidence=r["confidence"], tags=r["tags"], outcome=r["outcome"],
-        outcome_rating=r["outcome_rating"], resolved_at=r["resolved_at"],
-    )
-
-
-def log_decision(situation: str, choice: str, options: str | None = None,
-                 rationale: str | None = None, confidence: int | None = None,
-                 tags: str | None = None) -> int:
-    """Record a decision Brian made. Embeds situation+choice so similar future calls
-    can recall it. Returns the new row id. Resolve it later with resolve_decision."""
-    now = datetime.now(timezone.utc).isoformat()
-    try:
-        [emb] = llm.embed([f"{situation}\nChose: {choice}"])
-        blob = _to_blob(emb)
-    except Exception:
-        blob = None  # never block logging a decision on the embedder being down
-    conn = _connection()
-    with conn:
-        cur = conn.execute(
-            "INSERT INTO decisions (created_at, situation, options, choice, rationale, "
-            "confidence, tags, embedding) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            (now, situation, options, choice, rationale, confidence, tags, blob),
-        )
-    return int(cur.lastrowid)
-
-
-def resolve_decision(decision_id: int, outcome: str, outcome_rating: int | None = None) -> bool:
-    """Record how a past decision turned out. Returns False if the id is unknown."""
-    now = datetime.now(timezone.utc).isoformat()
-    conn = _connection()
-    with conn:
-        cur = conn.execute(
-            "UPDATE decisions SET outcome = ?, outcome_rating = ?, resolved_at = ? WHERE id = ?",
-            (outcome, outcome_rating, now, decision_id),
-        )
-    return cur.rowcount > 0
-
-
-def get_decision(decision_id: int) -> Decision | None:
-    r = _connection().execute("SELECT * FROM decisions WHERE id = ?", (decision_id,)).fetchone()
-    return _row_to_decision(r) if r else None
-
-
-def list_decisions(limit: int = 20, open_only: bool = False) -> list[Decision]:
-    """Recent decisions, newest first. open_only -> only those not yet resolved."""
-    sql = "SELECT * FROM decisions"
-    if open_only:
-        sql += " WHERE resolved_at IS NULL"
-    sql += " ORDER BY created_at DESC LIMIT ?"
-    rows = _connection().execute(sql, (limit,)).fetchall()
-    return [_row_to_decision(r) for r in rows]
-
-
-def recall_decisions(query: str, k: int = 5) -> list[Decision]:
-    """Top-k past decisions semantically similar to `query`, each with a `score` — so a
-    new call can lean on how similar ones went. Resolved rows carry the real signal."""
-    [q_vec] = llm.embed([query])
-    q = np.asarray(q_vec, dtype=np.float32)
-    rows = _connection().execute(
-        "SELECT * FROM decisions WHERE embedding IS NOT NULL"
-    ).fetchall()
-    if not rows:
-        return []
-    matrix = np.stack([_from_blob(r["embedding"]) for r in rows])
-    norms = np.linalg.norm(matrix, axis=1)
-    scores = (matrix @ q) / (norms * np.linalg.norm(q) + 1e-9)
-    top_idx = np.argsort(scores)[::-1][:k]
-    out = []
-    for i in top_idx:
-        d = _row_to_decision(rows[i])
-        d.score = float(scores[i])
-        out.append(d)
-    return out
-
-
 def get_setting(key: str, default: str | None = None) -> str | None:
     """A runtime setting value (UI-tunable), or `default` if unset."""
     r = _connection().execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone()

lyra/modes.py

@@ -67,11 +67,17 @@ _CASH_CARD = """You are copiloting Brian's LIVE cash game right now — you're a
 a session is (or should be) open. You move between two registers depending on what he's doing:
 
 • HE HANDS YOU FACTS TO TRACK — his stack, a hand, a read on someone, a rebuy, a result. \
-Log it with the right tool and confirm in ONE short line ("$350 stack logged."). Don't \
-narrate, don't explain what logging is, don't ask permission — just do it. He says his \
-current stack → log_stack. He describes a hand → log_hand (terse) or record_hand (a full \
-hand he wants saved/replayable). A read on a player → add_read. A rebuy → add_buyin. This is \
-the quiet, fast half of the job; he shouldn't feel you working.
+LOGGING IS THE JOB: if his message contains anything trackable, you MUST call the tool \
+FIRST, before you reply — every single time. Logging and talking are not either/or; do \
+BOTH. Never let a conversational reply take the place of the log. A described hand ALWAYS \
+gets logged, even mid-banter, even if he's just telling a story about it — don't skip the \
+hand because you're busy reacting to it. Then confirm in ONE short line ("$350 stack \
+logged."). Don't narrate, don't explain logging, don't ask permission — just do it. \
+Routing: current stack → log_stack (and pass `note` with the why if he gives one — "card \
+dead", "doubled up vs the LAG"). A hand he describes → record_hand (a real, replayable \
+hand) — prefer this over log_hand so it lands on his timeline with a link. A read on a \
+player → add_read. A rebuy → add_buyin. A result/pot → it rides with the hand. This is the \
+quiet, fast half of the job; he shouldn't feel you working, but it must always happen.
 
 • HE ASKS FOR ADVICE, OR TELLS YOU HOW HE'S FEELING — tilted, steaming, card-dead, bored, \
 stuck, "should I have folded the river?" THIS is when he needs you most. Drop the shorthand \

lyra/poker.py

@@ -16,7 +16,7 @@ import json
 import re
 from datetime import datetime, timezone
 
-from lyra import llm, memory
+from lyra import clock, llm, memory
 
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS poker_sessions (
@@ -138,7 +138,8 @@ def _c():
         conn.executescript(_SCHEMA)
         # Add columns introduced after a DB already had the tables (no-op if present).
         for ddl in ("ALTER TABLE poker_hands ADD COLUMN structured TEXT",
-                    "ALTER TABLE poker_sessions ADD COLUMN chat_session_id TEXT"):
+                    "ALTER TABLE poker_sessions ADD COLUMN chat_session_id TEXT",
+                    "ALTER TABLE poker_stack_log ADD COLUMN note TEXT"):
             try:
                 conn.execute(ddl)
             except Exception:
@@ -403,17 +404,18 @@ def add_buyin(amount: float, session_id: int | None = None) -> float:
 
 # --- stack tracking ---
 
-def log_stack(amount: float, session_id: int | None = None) -> dict:
-    """Record Brian's current chip stack. Returns {current, buy_in, net} where net
-    is his live net while sitting (current stack − total bought in)."""
+def log_stack(amount: float, note: str | None = None, session_id: int | None = None) -> dict:
+    """Record Brian's current chip stack, optionally with the why ("card dead",
+    "doubled up vs Sal") — that context becomes the session-timeline line. Returns
+    {current, buy_in, net} where net is his live net while sitting."""
     sid = _resolve(session_id)
     if sid is None:
         raise ValueError("no live session")
     conn = _c()
     with conn:
         conn.execute(
-            "INSERT INTO poker_stack_log (session_id, amount, created_at) VALUES (?, ?, ?)",
-            (sid, float(amount), _now()),
+            "INSERT INTO poker_stack_log (session_id, amount, note, created_at) VALUES (?, ?, ?, ?)",
+            (sid, float(amount), (note or "").strip() or None, _now()),
         )
     return stack_state(sid)
 
@@ -436,7 +438,7 @@ def stack_log(session_id: int | None = None) -> list[dict]:
     if sid is None:
         return []
     return [dict(r) for r in _c().execute(
-        "SELECT id, amount, created_at FROM poker_stack_log WHERE session_id = ? ORDER BY id",
+        "SELECT id, amount, note, created_at FROM poker_stack_log WHERE session_id = ? ORDER BY id",
         (sid,),
     ).fetchall()]
 
@@ -651,38 +653,102 @@ def _review_session_id() -> int:
     return int(cur.lastrowid)
 
 
+# --- the canonical structured-hand contract (see docs/HAND_HISTORY.md) ---------
+# This is the single shape that gets stored, replayed by the viewer, and exported to
+# RTO. The LLM parser produces it today; the tap recorder will produce it natively.
+HAND_SCHEMA_VERSION = 1
+POSITIONS = ("UTG", "UTG1", "UTG2", "MP", "LJ", "HJ", "CO", "BTN", "SB", "BB")
+ACTION_VERBS = ("post", "fold", "check", "call", "bet", "raise", "allin")
+STREETS = ("preflop", "flop", "turn", "river")
+
 _SUIT_SYM = {"♥": "h", "♦": "d", "♣": "c", "♠": "s"}
 
 
 def _norm_card(c):
+    """Canonicalize one card string: unicode suit -> letter, '10' -> 'T', rank upper,
+    suit lower (e.g. '10♥' -> 'Th', 'as' -> 'As'). Unknown placeholders are preserved:
+    'Ax' = known rank/unknown suit, 'x' = fully unknown card."""
     if not isinstance(c, str):
         return c
     s = c.strip()
     for sym, ltr in _SUIT_SYM.items():
         s = s.replace(sym, ltr)
+    s = s.replace("10", "T")
+    if len(s) == 2:
+        s = s[0].upper() + s[1].lower()  # 'Ax' stays 'Ax'; 'x' (len 1) untouched
     return s
 
 
-def _normalize_parsed(p: dict) -> dict:
-    """Normalize card strings (unicode suits -> letters) across a parsed hand."""
-    if not isinstance(p, dict):
-        return p
-    for key in ("hero_cards", "board"):
-        if isinstance(p.get(key), list):
-            p[key] = [_norm_card(c) for c in p[key]]
+def _card_known(c) -> bool:
+    """True only for a fully specified card (rank+suit, no 'x' placeholder)."""
+    return isinstance(c, str) and len(c) == 2 and "x" not in c.lower()
+
+
+def _completeness(p: dict) -> dict:
+    """Which parts of the hand are fully specified — lets a consumer (RTO) use what it
+    can and skip suit-dependent math (flushes) on hands where suits weren't recorded."""
+    shown = [c for pl in (p.get("players") or []) if isinstance(pl.get("cards"), list)
+             for c in pl["cards"]]
+    hole = list(p.get("hero_cards") or []) + shown
+    return {
+        "cards": bool(hole) and all(_card_known(c) for c in hole),
+        "board": all(_card_known(c) for c in (p.get("board") or [])),
+        "actions": bool(p.get("actions")),
+    }
+
+
+def normalize_structured(parsed: dict) -> dict:
+    """Canonicalize a structured hand — from the LLM parser OR (later) the tap recorder —
+    into the versioned contract shape: normalized cards, the hero synced into players[]
+    (RTO finds the hero via pos == hero_pos), a schema_version stamp, and a completeness
+    summary. Idempotent — the single shape stored, replayed, and exported."""
+    if not isinstance(parsed, dict):
+        return parsed
+    p = dict(parsed)
+    p["schema_version"] = HAND_SCHEMA_VERSION
+    p["hero_cards"] = [_norm_card(c) for c in (p.get("hero_cards") or [])]
+    p["board"] = [_norm_card(c) for c in (p.get("board") or [])]
+
+    players = []
     for pl in p.get("players") or []:
-        if isinstance(pl, dict) and isinstance(pl.get("cards"), list):
+        if not isinstance(pl, dict):
+            continue
+        pl = dict(pl)
+        if isinstance(pl.get("cards"), list):
             pl["cards"] = [_norm_card(c) for c in pl["cards"]]
+        pl.pop("hero", None)  # recomputed below so it can't go stale
+        players.append(pl)
+
+    # Hero must appear in players[] (with cards) — RTO reads the hero off pos==hero_pos.
+    hero_pos = p.get("hero_pos")
+    if hero_pos:
+        hero = next((pl for pl in players if pl.get("pos") == hero_pos), None)
+        if hero is None:
+            hero = {"pos": hero_pos}
+            players.insert(0, hero)
+        hero["hero"] = True
+        if p["hero_cards"] and not hero.get("cards"):
+            hero["cards"] = list(p["hero_cards"])
+    p["players"] = players
+
+    actions = []
     for a in p.get("actions") or []:
-        if isinstance(a, dict) and isinstance(a.get("board"), list):
+        if not isinstance(a, dict):
+            continue
+        a = dict(a)
+        if isinstance(a.get("board"), list):
             a["board"] = [_norm_card(c) for c in a["board"]]
+        actions.append(a)
+    p["actions"] = actions
+
+    p["completeness"] = _completeness(p)
     return p
 
 
 def store_hand_history(parsed: dict, session_id: int | None = None,
                        tag: str | None = None, lesson: str | None = None) -> int:
     """Store a parsed hand: full JSON + extracted flat fields for stats/listing."""
-    parsed = _normalize_parsed(parsed)
+    parsed = normalize_structured(parsed)
     sid = _resolve(session_id) or _review_session_id()
     hero_cards = parsed.get("hero_cards") or []
     board = parsed.get("board") or []
@@ -736,7 +802,7 @@ def reconstruct_hand(hand_id: int, backend: str | None = None) -> dict | None:
     parsed = parse_hand(shorthand, backend=backend)
     if not parsed:
         return None
-    parsed = _normalize_parsed(parsed)
+    parsed = normalize_structured(parsed)
     conn = _c()
     with conn:
         conn.execute("UPDATE poker_hands SET structured = ? WHERE id = ?",
@@ -751,19 +817,29 @@ def get_hand(hand_id: int) -> dict | None:
     if not r:
         return None
     d = dict(r)
-    d["structured"] = json.loads(d["structured"]) if d.get("structured") else None
+    # Normalize on read too: legacy rows predate the contract, and it's idempotent for
+    # new ones — so /hand/{id}/data always serves the current versioned shape.
+    d["structured"] = normalize_structured(json.loads(d["structured"])) if d.get("structured") else None
     return d
 
 
 def list_recent_hands(limit: int = 60) -> list[dict]:
-    """Recent recorded hands with their session's venue/stakes, for browsing."""
+    """Recent recorded hands with their session's venue/stakes, for browsing. Each carries
+    has_structured so a consumer (the export, RTO) knows which hands have a replayable
+    structured body worth fetching via /hand/{id}/data vs. flat quick-logs."""
     rows = _c().execute(
         "SELECT h.id, h.position, h.hole_cards, h.board, h.result, h.tag, h.at, "
-        "h.lesson, s.venue AS venue, s.stakes AS stakes "
+        "h.lesson, (h.structured IS NOT NULL) AS has_structured, "
+        "s.venue AS venue, s.stakes AS stakes "
         "FROM poker_hands h LEFT JOIN poker_sessions s ON s.id = h.session_id "
         "ORDER BY h.id DESC LIMIT ?", (limit,),
     ).fetchall()
-    return [dict(r) for r in rows]
+    out = []
+    for r in rows:
+        d = dict(r)
+        d["has_structured"] = bool(d["has_structured"])
+        out.append(d)
+    return out
 
 
 # --- session recap (.md generation on top of structured data + conversation) ---
@@ -1105,6 +1181,51 @@ def running_stats(stakes: str | None = None, venue: str | None = None,
 
 # --- live session HUD (everything tracked in the current session, for the UI) ---
 
+def timeline(session_id: int | None = None) -> list[dict]:
+    """The session's running log: start, stack updates (+context), hands (linkable),
+    reads, and rituals, interleaved chronologically with local time-of-day stamps.
+    This is what Brian sees as the night's story — '10:45 start … 12:00a doubled up,
+    $750 (hand)'. Each entry: {time, at, kind, text, hand_id?, amount?, result?}."""
+    sid = _resolve(session_id)
+    if sid is None:
+        return []
+    s = get_session(sid) or {}
+    events: list[dict] = []
+
+    if s.get("started_at"):
+        bits = [s.get("stakes"), s.get("game"), f"at {s['venue']}" if s.get("venue") else None]
+        label = " ".join(b for b in bits if b)
+        events.append({"at": s["started_at"], "kind": "start",
+                       "text": ("Session start — " + label) if label else "Session start"})
+
+    for r in stack_log(sid):
+        events.append({"at": r["created_at"], "kind": "stack",
+                       "amount": r.get("amount"), "text": r.get("note") or "stack update"})
+
+    for h in list_hands(sid):
+        desc = " ".join(b for b in (h.get("position"), h.get("hole_cards")) if b)
+        events.append({"at": h["at"], "kind": "hand", "hand_id": h["id"],
+                       "result": h.get("result"), "text": desc or "hand"})
+
+    for r in _c().execute(
+        "SELECT pr.created_at AS at, pr.seat AS seat, pr.note AS note, p.name AS name "
+        "FROM player_reads pr LEFT JOIN poker_players p ON p.id = pr.player_id "
+        "WHERE pr.session_id = ?", (sid,),
+    ).fetchall():
+        who = r["name"] or (f"seat {r['seat']}" if r["seat"] else "villain")
+        events.append({"at": r["at"], "kind": "read", "text": f"Read — {who}: {r['note']}"})
+
+    for r in list_rituals(sid):
+        tag = f"[{r['classification']}] " if r.get("classification") else ""
+        events.append({"at": r["created_at"], "kind": r["kind"],
+                       "text": tag + (r.get("content") or r["kind"]), "hand_id": r.get("hand_id")})
+
+    events.sort(key=lambda e: e["at"] or "")
+    for e in events:
+        e["time"] = clock.short(e["at"])
+    return events
+
+
 def _session_villains(sid: int) -> list[dict]:
     """Players read this session, with their standing dossier fields."""
     rows = _c().execute(
@@ -1177,6 +1298,7 @@ def hud(session_id: int | None = None) -> dict | None:
         },
         "hands": hands,
         "villains": _session_villains(sid),
+        "timeline": timeline(sid),
         "notes": notes,
         "rituals": {
             "alligator": alligator_active(sid),

lyra/summary.py

@@ -129,16 +129,20 @@ def maybe_summarize_async(session_id: str, backend: Backend | None = None) -> No
 
 
 def summarize_all(
-    backend: Backend | None = None, limit: int | None = None, workers: int = 8
+    backend: Backend | None = None, limit: int | None = None, workers: int | None = None
 ) -> dict:
     """Summarize every session that needs it. Idempotent and resumable.
 
-    LLM summarization runs concurrently across `workers` threads (great for a
-    cloud backend). DB reads (loading transcripts) and writes (store_summary,
-    which also embeds) happen on the main thread, so the single SQLite
-    connection is never touched from multiple threads.
+    Concurrency is backend-aware: the cloud API parallelizes happily, but the
+    local/MI50 GPU servers run a single slot (llama.cpp --parallel 1) — firing N
+    requests at them just queues, blows the client timeout, and thrashes the KV
+    cache (wasted compute + heat). So GPU backends run serially unless overridden.
+    DB reads/writes (store_summary embeds) stay on the main thread, so the single
+    SQLite connection is never touched from multiple threads.
     """
     backend = backend or config.load().summary_backend
+    if workers is None:
+        workers = 8 if backend == "cloud" else 1
 
     # Main thread: collect the work (transcripts) for sessions needing a summary.
     todo: list[tuple[str, str, int]] = []

lyra/tools.py

@@ -81,65 +81,6 @@ def _thought_response(args: dict, ctx: dict) -> str:
             "next time I'm thinking.")
 
 
-def _log_decision(args: dict, ctx: dict) -> str:
-    situation = (args.get("situation") or "").strip()
-    choice = (args.get("choice") or "").strip()
-    if not situation or not choice:
-        return "Need both what was being decided and the call you landed on."
-    conf = args.get("confidence")
-    try:
-        conf = int(conf) if conf is not None else None
-    except (TypeError, ValueError):
-        conf = None
-    did = memory.log_decision(
-        situation=situation, choice=choice,
-        options=(args.get("options") or "").strip() or None,
-        rationale=(args.get("rationale") or "").strip() or None,
-        confidence=conf, tags=(args.get("tags") or "").strip() or None,
-    )
-    logbus.log("info", "decision logged (tool)", id=did)
-    return (f"Logged decision #{did}. When you know how it played out, tell me and "
-            "I'll close the loop on it.")
-
-
-def _resolve_decision(args: dict, ctx: dict) -> str:
-    try:
-        did = int(args.get("decision_id"))
-    except (TypeError, ValueError):
-        return "Which decision? I need its id (#number)."
-    outcome = (args.get("outcome") or "").strip()
-    if not outcome:
-        return "Tell me how it turned out so I can record the outcome."
-    rating = args.get("rating")
-    try:
-        rating = int(rating) if rating is not None else None
-    except (TypeError, ValueError):
-        rating = None
-    if not memory.resolve_decision(did, outcome, rating):
-        return f"(couldn't find decision #{did})"
-    logbus.log("info", "decision resolved (tool)", id=did, rating=rating)
-    return f"Closed the loop on decision #{did}. That goes into how I weigh the next one."
-
-
-def _recall_decisions(args: dict, ctx: dict) -> str:
-    query = (args.get("query") or "").strip()
-    if not query:
-        return "Give me the gist of the call you're weighing and I'll pull similar past ones."
-    hits = memory.recall_decisions(query, k=int(args.get("k") or 4))
-    if not hits:
-        return "No comparable past decisions on record yet."
-    lines = []
-    for d in hits:
-        head = f"#{d.id} ({d.created_at[:10]}): {d.situation} → {d.choice}"
-        if d.resolved:
-            verdict = {1: "went well", 0: "mixed", -1: "went badly"}.get(d.outcome_rating, "resolved")
-            head += f" — {verdict}: {d.outcome}"
-        else:
-            head += " — outcome still open"
-        lines.append(head)
-    return "\n".join(lines)
-
-
 # name -> {spec (OpenAI function tool), handler}
 TOOLS: dict[str, dict] = {
     "journal_write": {
@@ -243,8 +184,9 @@ def _log_stack(args: dict, ctx: dict) -> str:
         amount = float(args.get("amount"))
     except (TypeError, ValueError):
         return "Give me a number for the stack."
+    note = (args.get("note") or "").strip() or None
     try:
-        st = poker.log_stack(amount)
+        st = poker.log_stack(amount, note=note)
     except ValueError:
         return "No live session — start one first, then I'll track your stack."
     net = st.get("net")
@@ -540,34 +482,6 @@ TOOLS.update({
         {"thread_id": {**_N, "description": "The thread id (#number) of the thought he reacted to."},
          "brian_said": {**_S, "description": "What Brian said / his take, in your words."}},
         ["thread_id", "brian_said"])},
-    "log_decision": {"handler": _log_decision, "spec": _f(
-        "log_decision",
-        "Record a real decision Brian lands on (especially in Decide mode) so it can "
-        "inform future calls. Capture it once he's settled — what he was deciding, the "
-        "call, and why. Outcome comes later via resolve_decision.",
-        {"situation": {**_S, "description": "What was being decided, in Brian's terms."},
-         "choice": {**_S, "description": "The call he landed on."},
-         "options": {**_S, "description": "The alternatives weighed (optional, newline/free text)."},
-         "rationale": {**_S, "description": "Why this call (optional)."},
-         "confidence": {**_N, "description": "How sure he was, 1-5 (optional)."},
-         "tags": {**_S, "description": "Domain, comma-separated: poker | life | build | ... (optional)."}},
-        ["situation", "choice"])},
-    "resolve_decision": {"handler": _resolve_decision, "spec": _f(
-        "resolve_decision",
-        "Close the loop on a previously logged decision once Brian knows how it turned "
-        "out. This is what makes the decision log learn — outcomes sharpen future calls.",
-        {"decision_id": {**_N, "description": "The decision id (#number)."},
-         "outcome": {**_S, "description": "What actually happened, in Brian's terms."},
-         "rating": {**_N, "description": "How it went: 1 good / 0 mixed / -1 bad (optional)."}},
-        ["decision_id", "outcome"])},
-    "recall_decisions": {"handler": _recall_decisions, "spec": _f(
-        "recall_decisions",
-        "Pull past decisions similar to one Brian's weighing now, with how they turned "
-        "out — so you can ground a recommendation in his own track record rather than "
-        "generic advice. Use it when he's deciding something with precedent.",
-        {"query": {**_S, "description": "The gist of the current call / situation."},
-         "k": {**_N, "description": "How many to pull (default 4)."}},
-        ["query"])},
     "start_session": {"handler": _start_session, "spec": _f(
         "start_session",
         "Begin a live poker session. Call when Brian sits down to play.",
@@ -606,8 +520,11 @@ TOOLS.update({
         "log_stack",
         "Record Brian's CURRENT total chip stack in the live session. Call whenever "
         "he states his stack ('I'm at 350', 'down to 220', 'stacked off to 900'). "
-        "Tracks his stack over time and his live net while he's still sitting.",
-        {"amount": {**_N, "description": "Current total chip stack, in dollars"}},
+        "Tracks his stack over time and his live net while he's still sitting. Pass "
+        "`note` with the WHY when he gives it ('card dead', 'doubled up vs the LAG') — "
+        "it becomes the line in his session timeline.",
+        {"amount": {**_N, "description": "Current total chip stack, in dollars"},
+         "note": {**_S, "description": "Optional context for the change, e.g. 'card dead', 'doubled up'"}},
         ["amount"])},
     "scar_note": {"handler": _scar_note, "spec": _f(
         "scar_note",

lyra/web/static/index.html

@@ -701,6 +701,16 @@
       window.addEventListener("resize", nudgeAppHeight);
       window.addEventListener("orientationchange", nudgeAppHeight);
 
+      // A rotation reflows the chat and iOS drops the scroll to mid-history. If we
+      // were pinned to the latest message, snap back there once the layout settles
+      // (re-fire across the reflow since iOS reports stale dimensions mid-rotate).
+      window.addEventListener("orientationchange", () => {
+        const m = document.getElementById("messages");
+        const wasAtBottom = m.scrollHeight - m.scrollTop - m.clientHeight < 90;
+        if (!wasAtBottom) return;  // respect the user's scroll-up position
+        [100, 300, 600].forEach((t) => setTimeout(() => { m.scrollTop = m.scrollHeight; }, t));
+      });
+
       // Keep the latest message in view when the keyboard opens/closes.
       const userInputEl = document.getElementById("userInput");
       userInputEl.addEventListener("focus", () => {

lyra/web/static/session.html

@@ -104,6 +104,16 @@
     .big-empty { text-align: center; padding: 50px 20px; color: var(--fade); }
     .big-empty .ico { font-size: 2.4rem; }
     .big-empty a { color: var(--accent); text-decoration: none; }
+    /* running timeline */
+    ul.tl { list-style: none; margin: 0; padding: 0; }
+    ul.tl li { display: flex; gap: 10px; padding: 8px 0; border-bottom: 1px solid var(--bg-line); align-items: baseline; font-size: .92rem; line-height: 1.4; }
+    ul.tl li:last-child { border-bottom: none; }
+    .tl-time { color: var(--fade); font-variant-numeric: tabular-nums; font-size: .78rem; min-width: 60px; flex: none; }
+    .tl-body { flex: 1; }
+    .tl-amt { margin-left: 6px; font-variant-numeric: tabular-nums; }
+    li.start .tl-body { color: var(--accent); font-weight: 600; }
+    li.scar .tl-body, li.confidence .tl-body { font-style: italic; }
+    .tl-body a.hand { color: var(--accent); text-decoration: none; white-space: nowrap; }
   </style>
 </head>
 <body>
@@ -219,6 +229,7 @@
       }
       curSession = s;
       const stack = data.stack || {};
+      const timeline = data.timeline || [];
       const hands = data.hands || [];
       const villains = data.villains || [];
       const notes = data.notes || [];
@@ -277,6 +288,16 @@
           ${stack.current == null ? '<p class="empty" style="margin:12px 0 0">No stack logged yet — tell Lyra your stack ("I\'m at 350").</p>' : ''}
         </div>
 
+        <div class="card">
+          <p class="label">📜 Timeline</p>
+          ${timeline.length ? `<ul class="tl">${timeline.map(e => `
+            <li class="${esc(e.kind)}">
+              <span class="tl-time">${esc(e.time)}</span>
+              <span class="tl-body">${esc(e.text)}${e.amount != null ? ` <b class="tl-amt">${money(e.amount)}</b>` : ''}${e.result != null ? ` <span class="res ${e.result>=0?'up':'down'}">${signed(e.result)}</span>` : ''}${e.hand_id ? ` <a class="hand" href="/hand/${e.hand_id}">hand ›</a>` : ''}</span>
+            </li>`).join('')}</ul>`
+            : '<p class="empty">Nothing yet tonight — the running log fills in as you play.</p>'}
+        </div>
+
         <div class="card">
           <p class="label">Hands this session</p>
           ${hands.length ? `<ul class="rows">${hands.slice().reverse().map(h => `

lyra/web/static/style.css

@@ -56,6 +56,10 @@ body.dark {
 
 html {
   overscroll-behavior: none;
+  /* Stop iOS from inflating font sizes when the device rotates to landscape (and
+     leaving them big on rotate back). Every other page sets this; the chat didn't. */
+  -webkit-text-size-adjust: 100%;
+  text-size-adjust: 100%;
 }
 
 body {

tests/test_decisions.py

@@ -1,103 +0,0 @@
-"""Decision log (Decide mode's learning layer): log -> resolve -> recall, + tools."""
-from __future__ import annotations
-
-import importlib
-
-import pytest
-
-
-@pytest.fixture
-def mem(tmp_path, monkeypatch):
-    monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
-    from lyra import llm
-    # Deterministic, content-dependent embeddings so recall ordering is meaningful:
-    # "cleveland"/"tournament" cluster on axis 0, "stocks"/"money" on axis 1.
-    def fake_embed(texts):
-        out = []
-        for t in texts:
-            t = t.lower()
-            poker = sum(w in t for w in ("tournament", "cleveland", "poker", "buy-in"))
-            money = sum(w in t for w in ("stocks", "money", "invest", "sell"))
-            out.append([float(poker), float(money), 0.1])
-        return out
-    monkeypatch.setattr(llm, "embed", fake_embed)
-    import lyra.memory as memory
-    importlib.reload(memory)
-    return memory
-
-
-def test_log_and_get_roundtrip(mem):
-    did = mem.log_decision(
-        situation="Play the Cleveland turbo tournament tomorrow?",
-        choice="Yes, but only the noon flight",
-        options="skip it / noon flight / both flights",
-        rationale="20-min levels suit my aggression; one flight caps the variance",
-        confidence=4, tags="poker,tournament",
-    )
-    d = mem.get_decision(did)
-    assert d.situation.startswith("Play the Cleveland")
-    assert d.choice == "Yes, but only the noon flight"
-    assert d.confidence == 4 and d.tags == "poker,tournament"
-    assert not d.resolved and d.outcome is None
-
-
-def test_resolve_closes_the_loop(mem):
-    did = mem.log_decision(situation="Sell the stocks now?", choice="Hold")
-    assert mem.resolve_decision(did, "Recovered 12% the next week", outcome_rating=1)
-    d = mem.get_decision(did)
-    assert d.resolved and d.outcome_rating == 1
-    assert "Recovered" in d.outcome and d.resolved_at is not None
-
-
-def test_resolve_unknown_id_is_false(mem):
-    assert mem.resolve_decision(999, "n/a") is False
-
-
-def test_list_open_only_filters_resolved(mem):
-    a = mem.log_decision(situation="A?", choice="x")
-    mem.log_decision(situation="B?", choice="y")
-    mem.resolve_decision(a, "done", 0)
-    assert {d.situation for d in mem.list_decisions(open_only=True)} == {"B?"}
-    assert len(mem.list_decisions()) == 2
-
-
-def test_recall_ranks_by_similarity(mem):
-    mem.log_decision(situation="Which Cleveland tournament flight?", choice="noon")
-    mem.log_decision(situation="Should I sell the stocks?", choice="hold")
-    hits = mem.recall_decisions("another poker tournament buy-in", k=2)
-    assert hits[0].situation.startswith("Which Cleveland")   # poker cluster ranks first
-    assert hits[0].score >= hits[1].score
-
-
-# --- tool layer ---------------------------------------------------------------
-
-def test_log_decision_tool_persists(mem):
-    from lyra import tools
-    out = tools.dispatch("log_decision",
-                         {"situation": "Move the MI50 to auto clocks?", "choice": "yes",
-                          "confidence": "3", "tags": "build"})
-    assert "#1" in out
-    d = mem.get_decision(1)
-    assert d.choice == "yes" and d.confidence == 3 and d.tags == "build"
-
-
-def test_log_decision_tool_requires_both_fields(mem):
-    from lyra import tools
-    assert "Need both" in tools.dispatch("log_decision", {"situation": "just this"})
-
-
-def test_resolve_decision_tool(mem):
-    from lyra import tools
-    did = mem.log_decision(situation="X?", choice="y")
-    out = tools.dispatch("resolve_decision",
-                         {"decision_id": did, "outcome": "worked out", "rating": "1"})
-    assert f"#{did}" in out
-    assert mem.get_decision(did).outcome_rating == 1
-
-
-def test_recall_decisions_tool_surfaces_outcomes(mem):
-    from lyra import tools
-    did = mem.log_decision(situation="Cleveland tournament again?", choice="play")
-    mem.resolve_decision(did, "min-cashed", outcome_rating=0)
-    out = tools.dispatch("recall_decisions", {"query": "poker tournament tomorrow"})
-    assert "Cleveland" in out and "mixed" in out

tests/test_hand_schema.py

@@ -0,0 +1,103 @@
+"""The canonical structured-hand contract (docs/HAND_HISTORY.md): normalize + export.
+
+normalize_structured() is the single guarantee that every stored / replayed / exported
+hand has the versioned shape RTO consumes.
+"""
+from __future__ import annotations
+
+import importlib
+
+import pytest
+
+
+@pytest.fixture
+def poker(tmp_path, monkeypatch):
+    monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
+    from lyra import llm
+    monkeypatch.setattr(llm, "embed", lambda texts: [[0.1, 0.2, 0.3] for _ in texts])
+    import lyra.memory as memory
+    importlib.reload(memory)
+    import lyra.poker as poker
+    importlib.reload(poker)
+    return poker
+
+
+def _full_hand():
+    return {
+        "game": "NLH", "stakes": "1/3", "hero_pos": "BTN",
+        "hero_cards": ["ah", "kh"],
+        "players": [
+            {"pos": "BTN", "stack": 300, "name": "Hero"},
+            {"pos": "BB", "stack": 250, "name": "Sal", "cards": ["qs", "qd"]},
+        ],
+        "actions": [
+            {"street": "preflop", "pos": "BTN", "action": "raise", "amount": 15},
+            {"street": "flop", "board": ["7♦", "2♣", "5♥"]},
+            {"street": "flop", "pos": "BB", "action": "check"},
+        ],
+        "board": ["7♦", "2♣", "5♥"],
+        "result": {"pot": 40, "hero_net": 25, "summary": "won at showdown"},
+    }
+
+
+def test_stamps_version(poker):
+    out = poker.normalize_structured({"hero_pos": "CO"})
+    assert out["schema_version"] == poker.HAND_SCHEMA_VERSION
+
+
+def test_card_normalization(poker):
+    out = poker.normalize_structured(_full_hand())
+    assert out["hero_cards"] == ["Ah", "Kh"]            # lowercased input -> canonical
+    assert out["board"] == ["7d", "2c", "5h"]           # unicode suits -> letters
+    assert out["actions"][1]["board"] == ["7d", "2c", "5h"]
+    # ten + suit symbol together
+    assert poker.normalize_structured({"board": ["10♠"]})["board"] == ["Ts"]
+
+
+def test_unknown_cards_preserved(poker):
+    out = poker.normalize_structured({"hero_cards": ["Ax", "x"], "board": ["Ax", "4x", "x"]})
+    assert out["hero_cards"] == ["Ax", "x"]             # placeholders kept, not dropped
+    assert out["completeness"]["cards"] is False
+    assert out["completeness"]["board"] is False
+
+
+def test_hero_synced_into_players(poker):
+    out = poker.normalize_structured(_full_hand())
+    hero = next(p for p in out["players"] if p["pos"] == "BTN")
+    assert hero["hero"] is True
+    assert hero["cards"] == ["Ah", "Kh"]               # mirrored from hero_cards
+    assert sum(1 for p in out["players"] if p.get("hero")) == 1
+
+
+def test_hero_inserted_when_missing_from_players(poker):
+    out = poker.normalize_structured({"hero_pos": "SB", "hero_cards": ["As", "Ad"], "players": []})
+    assert out["players"] == [{"pos": "SB", "hero": True, "cards": ["As", "Ad"]}]
+
+
+def test_completeness_full_hand(poker):
+    c = poker.normalize_structured(_full_hand())["completeness"]
+    assert c == {"cards": True, "board": True, "actions": True}
+
+
+def test_idempotent(poker):
+    once = poker.normalize_structured(_full_hand())
+    twice = poker.normalize_structured(once)
+    assert once == twice
+
+
+def test_store_and_get_roundtrip_is_normalized(poker):
+    sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
+    hid = poker.store_hand_history(_full_hand(), session_id=sid, tag="well_played")
+    got = poker.get_hand(hid)["structured"]
+    assert got["schema_version"] == poker.HAND_SCHEMA_VERSION
+    assert got["board"] == ["7d", "2c", "5h"]
+    assert got["completeness"]["cards"] is True
+
+
+def test_list_recent_hands_flags_structured(poker):
+    sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
+    structured_id = poker.store_hand_history(_full_hand(), session_id=sid)
+    flat_id = poker.log_hand(session_id=sid, position="CO", hole_cards="Jc Jd")
+    rows = {r["id"]: r for r in poker.list_recent_hands()}
+    assert rows[structured_id]["has_structured"] is True
+    assert rows[flat_id]["has_structured"] is False