feat: decision-log data layer for Decide mode (learning layer)

Storage + tools so Decide mode can learn instead of one-shot tie-breaking: log
the call Brian makes, resolve it later with the outcome, recall similar past calls
to ground new recommendations in his own track record.

- memory: decisions table + Decision dataclass + log/resolve/get/list/recall_decisions
  (embedding over situation+choice; embed failure never blocks a log)
- tools: log_decision / resolve_decision / recall_decisions handlers + specs
- tests: 9 covering roundtrip, resolve, open-only filter, similarity rank, tool layer

Data layer only — NOT wired into any mode's allow-list or the Decide card yet
(the prompt/taste part is left for Brian; see docs/DECISION_LOG.md). No behavior
changes until the tools are added to _DECIDE_TOOLS.

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

docs/DECISION_LOG.md

@@ -0,0 +1,48 @@
+# 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

@@ -1,72 +0,0 @@
-# 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.

lyra/clock.py

@@ -9,39 +9,20 @@ 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 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")
+    """Wall-clock stamp, e.g. 'Wednesday, 17 Jun 2026, 01:50 UTC'."""
+    return (dt or now()).strftime("%A, %d %b %Y, %H:%M UTC")
 
 
 def gap_seconds(since_iso: str | None, ref: datetime | None = None) -> float | None:

lyra/llm.py

@@ -2,13 +2,11 @@
 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
 
 
@@ -20,54 +18,30 @@ 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=mdl, messages=messages)
-        out = resp.choices[0].message.content or ""
-    elif backend == "mi50":
+        resp = client.chat.completions.create(model=model or cfg.cloud_model, messages=messages)
+        return resp.choices[0].message.content or ""
+
+    if 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=mdl, messages=messages)
-        out = resp.choices[0].message.content or ""
-    else:
-        resp = httpx.post(
-            f"{cfg.local_base_url}/api/chat",
-            json={"model": mdl, "messages": messages, "stream": False},
-            timeout=120,
-        )
-        resp.raise_for_status()
-        out = resp.json()["message"]["content"]
+        resp = client.chat.completions.create(model=model or cfg.mi50_model, messages=messages)
+        return resp.choices[0].message.content or ""
 
-    logbus.log("info", "llm done", kind="complete", backend=backend,
-               ms=int((time.monotonic() - t0) * 1000), out=len(out))
-    return out
+    resp = httpx.post(
+        f"{cfg.local_base_url}/api/chat",
+        json={"model": model or cfg.local_model, "messages": messages, "stream": False},
+        timeout=120,
+    )
+    resp.raise_for_status()
+    return resp.json()["message"]["content"]
 
 
 def chat_call(
@@ -94,8 +68,6 @@ 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):
@@ -103,9 +75,6 @@ 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.
@@ -136,8 +105,6 @@ 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):
@@ -156,9 +123,6 @@ 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,6 +115,26 @@ 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
@@ -184,6 +204,26 @@ 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()
 
@@ -645,6 +685,87 @@ 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,17 +67,11 @@ _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. \
-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.
+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.
 
 • 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 clock, llm, memory
+from lyra import llm, memory
 
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS poker_sessions (
@@ -138,8 +138,7 @@ 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_stack_log ADD COLUMN note TEXT"):
+                    "ALTER TABLE poker_sessions ADD COLUMN chat_session_id TEXT"):
             try:
                 conn.execute(ddl)
             except Exception:
@@ -404,18 +403,17 @@ def add_buyin(amount: float, session_id: int | None = None) -> float:
 
 # --- stack tracking ---
 
-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."""
+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)."""
     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, note, created_at) VALUES (?, ?, ?, ?)",
-            (sid, float(amount), (note or "").strip() or None, _now()),
+            "INSERT INTO poker_stack_log (session_id, amount, created_at) VALUES (?, ?, ?)",
+            (sid, float(amount), _now()),
         )
     return stack_state(sid)
 
@@ -438,7 +436,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, note, created_at FROM poker_stack_log WHERE session_id = ? ORDER BY id",
+        "SELECT id, amount, created_at FROM poker_stack_log WHERE session_id = ? ORDER BY id",
         (sid,),
     ).fetchall()]
 
@@ -653,102 +651,38 @@ 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 _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 = []
+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]]
     for pl in p.get("players") or []:
-        if not isinstance(pl, dict):
-            continue
-        pl = dict(pl)
-        if isinstance(pl.get("cards"), list):
+        if isinstance(pl, dict) and 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 not isinstance(a, dict):
-            continue
-        a = dict(a)
-        if isinstance(a.get("board"), list):
+        if isinstance(a, dict) and 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_structured(parsed)
+    parsed = _normalize_parsed(parsed)
     sid = _resolve(session_id) or _review_session_id()
     hero_cards = parsed.get("hero_cards") or []
     board = parsed.get("board") or []
@@ -802,7 +736,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_structured(parsed)
+    parsed = _normalize_parsed(parsed)
     conn = _c()
     with conn:
         conn.execute("UPDATE poker_hands SET structured = ? WHERE id = ?",
@@ -817,29 +751,19 @@ def get_hand(hand_id: int) -> dict | None:
     if not r:
         return None
     d = dict(r)
-    # 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
+    d["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. 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."""
+    """Recent recorded hands with their session's venue/stakes, for browsing."""
     rows = _c().execute(
         "SELECT h.id, h.position, h.hole_cards, h.board, h.result, h.tag, h.at, "
-        "h.lesson, (h.structured IS NOT NULL) AS has_structured, "
-        "s.venue AS venue, s.stakes AS stakes "
+        "h.lesson, 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()
-    out = []
-    for r in rows:
-        d = dict(r)
-        d["has_structured"] = bool(d["has_structured"])
-        out.append(d)
-    return out
+    return [dict(r) for r in rows]
 
 
 # --- session recap (.md generation on top of structured data + conversation) ---
@@ -1181,51 +1105,6 @@ 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(
@@ -1298,7 +1177,6 @@ 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,20 +129,16 @@ 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 | None = None
+    backend: Backend | None = None, limit: int | None = None, workers: int = 8
 ) -> dict:
     """Summarize every session that needs it. Idempotent and resumable.
 
-    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.
+    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.
     """
     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,6 +81,65 @@ 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": {
@@ -184,9 +243,8 @@ 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, note=note)
+        st = poker.log_stack(amount)
     except ValueError:
         return "No live session — start one first, then I'll track your stack."
     net = st.get("net")
@@ -482,6 +540,34 @@ 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.",
@@ -520,11 +606,8 @@ 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. 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'"}},
+        "Tracks his stack over time and his live net while he's still sitting.",
+        {"amount": {**_N, "description": "Current total chip stack, in dollars"}},
         ["amount"])},
     "scar_note": {"handler": _scar_note, "spec": _f(
         "scar_note",

lyra/web/static/index.html

@@ -701,16 +701,6 @@
       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,16 +104,6 @@
     .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>
@@ -229,7 +219,6 @@
       }
       curSession = s;
       const stack = data.stack || {};
-      const timeline = data.timeline || [];
       const hands = data.hands || [];
       const villains = data.villains || [];
       const notes = data.notes || [];
@@ -288,16 +277,6 @@
           ${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,10 +56,6 @@ 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

@@ -0,0 +1,103 @@
+"""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

@@ -1,103 +0,0 @@
-"""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