Merge pull request 'update to 0.2.0 stable' (#2) from dev into main

Reviewed-on: #2

CHANGELOG.md

@@ -1,45 +1,5 @@
 # Changelog
 
-## 0.3.0 — session modes + live HUD
-
-Lyra stopped being a wishy-washy companion during live poker. She now switches
-register based on what she's actually doing at the table.
-
-### Conversation modes
-- **Two modes** — 💬 **Talk** (the companion, default) and ♠ **Cash** (live cash
-  copilot). A mode bundles a prompt card + a tool allow-list (`lyra/modes.py`).
-- **Two-register Cash voice** — quiet, act-first logging when Brian feeds facts
-  (stack, hand, read → logged in one line, no narration); full warm companion
-  voice when he asks for strategy or signals tilt/card-dead/steaming. Mental game
-  and strategy never get clipped.
-- **Tool gating by mode** — Talk offers journaling + read-only poker lookups;
-  Cash unlocks the full live toolset. `tools.specs(allow=…)` does the filtering.
-- **Auto-switch** — opening a session (`start_session`) flips the chat into Cash
-  mode automatically; the UI badge/HUD follow. Manual switch overrides anytime.
-- Mode persists per chat session (new `mode` column); Cash mode forces the cloud
-  backend, since tools only fire there.
-
-### Mental-game rituals
-- Brian's own rituals are now first-class, live tools (not just post-hoc recap
-  sections): **Scar Notes** (with the punt / cooler / standard distinction),
-  **Confidence Bank** (good process, banked regardless of result), **Alligator
-  Blood** mode (an invokable adversity state — she'll suggest it when he's
-  card-dead/short/stuck, and her coaching register shifts while it's on), and
-  **Reset** (a tilt circuit-breaker; mental marker, stats stay continuous).
-- Rituals show on the HUD (🐊 banner, Confidence Bank + Scar Notes panels) and feed
-  the recap's Scar Notes / Confidence Bank sections with what actually happened.
-
-### Session HUD
-- **Live HUD** at `/session` (bottom-nav tab on mobile, header link on desktop) —
-  polls every 5s: header (venue/stakes/elapsed/live net), stack with
-  **stack-over-time sparkline**, hands this session (tap → replay), villains seen,
-  her notes, and session stats.
-- **Stack tracking** — new `log_stack` tool + `poker_stack_log` table → current
-  stack, **live net while still sitting** (stack − buy-in), and the sparkline series.
-
-### Next
-- Strategy RAG (poker books/notes) plugs into Cash's coaching register.
-
 ## 0.2.0 — first working system
 
 The leap from "chat + memory baseline" to a working, persistent companion with a

README.md

@@ -43,22 +43,9 @@ reflected), and keeps a permanent **journal**.
 
 ## Poker copilot
 
-She runs in **modes** (`lyra/modes.py`). 💬 **Talk** is the default companion
-(journaling + read-only poker lookups). ♠ **Cash** is the live copilot: she gets
-the full session toolset and a two-register voice — quiet and act-first when
-you're feeding her facts to log (stack, a hand, a read → one-line confirm, no
-narration), but fully present and warm when you ask for strategy or you're tilting
-/ card-dead / steaming. Opening a session auto-switches her into Cash mode.
-
 Talk to her during a session; she drives tools behind the scenes:
 
 - **Session tracking** — `start_session`, `add_buyin`, `end_session` → net, hours, $/hr.
-- **Stack tracking** — `log_stack` records your stack as the night goes → live net
-  while you're still sitting, and a stack-over-time sparkline on the HUD.
-- **Mental-game rituals** — your own system, run live: **Scar Notes** (punt / cooler
-  / standard), **Confidence Bank** (good process, banked regardless of result),
-  **Alligator Blood** mode (adversity register she'll suggest when you're card-dead /
-  stuck), and **Reset** (tilt circuit-breaker). They surface on the HUD and ground the recap.
 - **Hand histories** — vomit rough shorthand ("AKs btn, 3bet, flop A72…"), she
   reconstructs a structured, **replayable** hand (unknown cards = `x`, never invented).
 - **Villain file** — named opponents auto-build persistent dossiers; basic stats
@@ -69,11 +56,9 @@ Talk to her during a session; she drives tools behind the scenes:
 
 ## Web app (served by `lyra-web`, default `:7078`)
 
-`/` chat (Markdown, model picker, 👍/👎 rating, **Talk/Cash mode switcher**) ·
-`/session` **live session HUD** (stack + sparkline, hands, villains, notes; mobile
-Session tab) · `/logs` live activity · `/self` read-her-mind (mood, drives,
-reflections) · `/journal` her thoughts · `/hands` recorded hands → `/hand/{id}`
-replayer · `/recap/{id}` session writeup (+ `.md` export).
+`/` chat (Markdown, model picker, 👍/👎 rating) · `/logs` live activity · `/self`
+read-her-mind (mood, drives, reflections) · `/journal` her thoughts · `/hands`
+recorded hands → `/hand/{id}` replayer · `/recap/{id}` session writeup (+ `.md` export).
 👍/👎 ratings on replies and thoughts are stored as `(context, content, rating)` —
 a fine-tune / preference dataset built passively (`/ratings/export` → JSONL).
 

lyra/chat.py

@@ -10,7 +10,7 @@ After replying, the session is compacted if enough new turns have accumulated.
 """
 from __future__ import annotations
 
-from lyra import clock, config, llm, logbus, memory, modes, persona, self_state, summary
+from lyra import clock, config, llm, logbus, memory, persona, self_state, summary
 from lyra import tools as toolkit
 from lyra.llm import Backend, Message
 
@@ -24,30 +24,6 @@ MAX_TOOL_ROUNDS = 5  # cap tool-call iterations per turn
 TOOL_BACKENDS = {"cloud"}
 
 
-def _mode_state_note(mode: modes.Mode | None) -> str | None:
-    """Dynamic, per-turn state for the active mode. Currently: surface Alligator
-    Blood while it's engaged on the live session, so she stays in that register."""
-    if not mode or mode.key != modes.CASH.key:
-        return None
-    from lyra import poker  # local import: keep the core/domain coupling at call time
-    if poker.alligator_active():
-        return (
-            "🐊 ALLIGATOR BLOOD is ON for this session. Coach Brian in that register: "
-            "hang around, refuse to die, don't force miracles, make opponents beat him "
-            "correctly. Tough, patient, steady — no heroics, no spew, no quitting."
-        )
-    return None
-
-
-def _maybe_switch_mode(session_id: str, tool_name: str) -> None:
-    """Keep the chat framing aligned with the live data: opening a poker session
-    auto-flips this chat into Cash mode (so the next turn gets the cash card + the
-    full live toolset). Manual UI switching still overrides anytime."""
-    if tool_name == "start_session":
-        memory.set_session_mode(session_id, modes.CASH.key)
-        logbus.log("info", "mode auto-switch", session=session_id, mode=modes.CASH.key)
-
-
 def _summary_note(summaries: list[memory.Summary]) -> Message:
     lines = [f"- ({(s.session_started_at or s.created_at)[:10]}) {s.content}" for s in summaries]
     body = "Gist of earlier sessions (compacted — ask if you need specifics):\n" + "\n".join(lines)
@@ -80,8 +56,7 @@ def _render(messages: list[Message]) -> str:
     return "\n\n".join(f"[{m['role']}]\n{m['content']}" for m in messages)
 
 
-def build_messages(session_id: str, user_msg: str,
-                   mode: modes.Mode | None = None) -> list[Message]:
+def build_messages(session_id: str, user_msg: str) -> list[Message]:
     """Assemble the full, tiered message list for one turn."""
     messages: list[Message] = [{"role": "system", "content": persona.system_prompt()}]
 
@@ -89,19 +64,6 @@ def build_messages(session_id: str, user_msg: str,
     # right after the persona — her sense of self before her model of the world.
     messages.append({"role": "system", "content": self_state.render_for_context(self_state.load())})
 
-    # Mode card: how to behave *right now* (e.g. live-cash copilot). High priority —
-    # it sits just after her sense of self, before her model of the world. Talk mode
-    # has no card (the persona's default voice is the Talk register).
-    if mode and mode.card:
-        messages.append({"role": "system", "content": mode.card})
-
-    # Live ritual state (e.g. Alligator Blood ON) — dynamic, so it rides alongside
-    # the static card and keeps her in-register for the whole stretch, not just the
-    # turn she flipped it.
-    state_note = _mode_state_note(mode)
-    if state_note:
-        messages.append({"role": "system", "content": state_note})
-
     # When she is: current time + the gap since Brian last spoke (she has no clock).
     messages.append(_now_note())
 
@@ -171,12 +133,11 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
         model=model, embed=cfg.embed_backend,
     )
 
-    mode = modes.get(memory.get_session_mode(session_id))
-    messages = build_messages(session_id, user_msg, mode=mode)
+    messages = build_messages(session_id, user_msg)
 
-    # Tool loop: offer Lyra her tools (scoped to the mode); if she calls one, run it
-    # and feed the result back so she can continue, until she returns a text reply.
-    tool_specs = toolkit.specs(mode.tools) if backend in TOOL_BACKENDS else None
+    # Tool loop: offer Lyra her tools; if she calls one, run it and feed the
+    # result back so she can continue, until she returns a normal text reply.
+    tool_specs = toolkit.specs() if backend in TOOL_BACKENDS else None
     ctx = {"session_id": session_id, "backend": backend}
     reply = ""
     for _ in range(MAX_TOOL_ROUNDS):
@@ -191,7 +152,6 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
             result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
             logbus.log("info", "tool call", session=session_id, tool=tc["name"], result=result[:80])
             messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
-            _maybe_switch_mode(session_id, tc["name"])
     if not reply:
         reply = "(I got tangled using my tools there — say that again?)"
     logbus.log("info", "reply", session=session_id, chars=len(reply))
@@ -200,64 +160,5 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
     memory.remember(session_id, "assistant", reply)
 
     # Compact this session once enough new turns have piled up.
-    summary.maybe_summarize_async(session_id)
+    summary.maybe_summarize(session_id)
     return reply
-
-
-def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
-                   model_override: str | None = None):
-    """Streaming generator version of `respond`.
-
-    Yields ("delta", text) as content streams in, and ("tool", name) when a tool
-    runs. Persists the full exchange and yields a final ("done", reply) — matching
-    `respond`'s side effects (memory + compaction) exactly.
-    """
-    cfg = config.load()
-    model = {"local": cfg.local_model, "cloud": cfg.chat_model, "mi50": cfg.mi50_model}.get(
-        backend, backend
-    )
-    if model_override and backend == "cloud":
-        model = model_override
-    logbus.log(
-        "info", "chat request (stream)", session=session_id, backend=backend,
-        model=model, embed=cfg.embed_backend,
-    )
-
-    mode = modes.get(memory.get_session_mode(session_id))
-    messages = build_messages(session_id, user_msg, mode=mode)
-    tool_specs = toolkit.specs(mode.tools) if backend in TOOL_BACKENDS else None
-    ctx = {"session_id": session_id, "backend": backend}
-    parts: list[str] = []
-    for _ in range(MAX_TOOL_ROUNDS):
-        assistant_msg = None
-        tool_calls = None
-        for ev, payload in llm.chat_call_stream(
-            messages, backend=backend, model=model, tools=tool_specs
-        ):
-            if ev == "delta":
-                parts.append(payload)
-                yield ("delta", payload)
-            elif ev == "message":
-                assistant_msg = payload
-            elif ev == "tool_calls":
-                tool_calls = payload
-        if not tool_calls:
-            break
-        messages.append(assistant_msg)  # her tool-call request
-        for tc in tool_calls:
-            result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
-            logbus.log("info", "tool call", session=session_id, tool=tc["name"], result=result[:80])
-            messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
-            _maybe_switch_mode(session_id, tc["name"])
-            yield ("tool", tc["name"])
-
-    reply = "".join(parts)
-    if not reply:
-        reply = "(I got tangled using my tools there — say that again?)"
-        yield ("delta", reply)
-    logbus.log("info", "reply", session=session_id, chars=len(reply))
-
-    memory.remember(session_id, "user", user_msg)
-    memory.remember(session_id, "assistant", reply)
-    summary.maybe_summarize_async(session_id)
-    yield ("done", reply)

lyra/llm.py

@@ -1,8 +1,7 @@
 """LLM router: local (Ollama) chat, cloud (OpenAI) chat + embeddings."""
 from __future__ import annotations
 
-import json
-from typing import Iterator, Literal, TypedDict
+from typing import Literal, TypedDict
 
 import httpx
 from openai import OpenAI
@@ -81,88 +80,6 @@ def chat_call(
     return {"role": "assistant", "content": complete(messages, backend=backend, model=model)}, None
 
 
-def chat_call_stream(
-    messages: list, backend: Backend = "cloud", model: str | None = None,
-    tools: list | None = None,
-) -> Iterator[tuple[str, object]]:
-    """Streaming variant of `chat_call`. Yields ("delta", text) for each content
-    chunk as it arrives, then exactly two terminal events:
-      ("message", assistant_dict)  — the full assistant turn, to append back
-      ("tool_calls", calls | None) — list of {id,name,arguments} or None
-
-    `local` (Ollama) streams NDJSON and never returns tool calls.
-    """
-    cfg = load()
-    if backend in ("cloud", "mi50"):
-        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)
-            mdl = model or cfg.cloud_model
-        else:
-            client = OpenAI(api_key="not-needed", base_url=cfg.mi50_base_url)
-            mdl = model or cfg.mi50_model
-        kwargs: dict = {"model": mdl, "messages": messages, "stream": True}
-        if tools:
-            kwargs["tools"] = tools
-        parts: list[str] = []
-        frags: dict[int, dict] = {}  # tool-call fragments accumulated by index
-        for chunk in client.chat.completions.create(**kwargs):
-            if not chunk.choices:
-                continue
-            delta = chunk.choices[0].delta
-            if getattr(delta, "content", None):
-                parts.append(delta.content)
-                yield ("delta", delta.content)
-            for tc in getattr(delta, "tool_calls", None) or []:
-                slot = frags.setdefault(tc.index, {"id": "", "name": "", "arguments": ""})
-                if tc.id:
-                    slot["id"] = tc.id
-                if tc.function and tc.function.name:
-                    slot["name"] = tc.function.name
-                if tc.function and tc.function.arguments:
-                    slot["arguments"] += tc.function.arguments
-        content = "".join(parts)
-        if frags:
-            calls = [frags[i] for i in sorted(frags)]
-            assistant = {
-                "role": "assistant",
-                "content": content or None,
-                "tool_calls": [
-                    {"id": c["id"], "type": "function",
-                     "function": {"name": c["name"], "arguments": c["arguments"]}}
-                    for c in calls
-                ],
-            }
-            yield ("message", assistant)
-            yield ("tool_calls", [{"id": c["id"], "name": c["name"], "arguments": c["arguments"]} for c in calls])
-        else:
-            yield ("message", {"role": "assistant", "content": content})
-            yield ("tool_calls", None)
-        return
-
-    # local (Ollama): stream NDJSON, no tools.
-    parts = []
-    with httpx.stream(
-        "POST", f"{cfg.local_base_url}/api/chat",
-        json={"model": model or cfg.local_model, "messages": messages, "stream": True},
-        timeout=120,
-    ) as resp:
-        resp.raise_for_status()
-        for line in resp.iter_lines():
-            if not line:
-                continue
-            data = json.loads(line)
-            piece = (data.get("message") or {}).get("content", "")
-            if piece:
-                parts.append(piece)
-                yield ("delta", piece)
-            if data.get("done"):
-                break
-    yield ("message", {"role": "assistant", "content": "".join(parts)})
-    yield ("tool_calls", None)
-
-
 def embed(texts: list[str]) -> list[list[float]]:
     """Embed texts using the configured backend (EMBED_BACKEND: "cloud" or "local").
 

lyra/memory.py

@@ -32,7 +32,6 @@ CREATE INDEX IF NOT EXISTS idx_session_created ON exchanges(session_id, created_
 CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
     name TEXT,
-    mode TEXT,            -- conversation mode (see lyra/modes.py); NULL = default
     created_at TEXT NOT NULL
 );
 
@@ -132,12 +131,6 @@ def _connection() -> sqlite3.Connection:
         _conn.execute("PRAGMA busy_timeout=5000")
         _conn.execute("PRAGMA journal_mode=WAL")
         _conn.executescript(SCHEMA)
-        # Migrations for DBs created before a column existed (no-op if present).
-        for ddl in ("ALTER TABLE sessions ADD COLUMN mode TEXT",):
-            try:
-                _conn.execute(ddl)
-            except sqlite3.OperationalError:
-                pass
         _conn_path = cfg.db_path
     return _conn
 
@@ -243,21 +236,6 @@ def ensure_session(session_id: str, name: str | None = None) -> None:
             conn.execute("UPDATE sessions SET name = ? WHERE id = ?", (name, session_id))
 
 
-def get_session_mode(session_id: str) -> str | None:
-    """The session's conversation mode key, or None if unset (caller applies default)."""
-    conn = _connection()
-    r = conn.execute("SELECT mode FROM sessions WHERE id = ?", (session_id,)).fetchone()
-    return r["mode"] if r and r["mode"] else None
-
-
-def set_session_mode(session_id: str, mode: str) -> None:
-    """Persist the session's conversation mode (creating the session row if needed)."""
-    ensure_session(session_id)
-    conn = _connection()
-    with conn:
-        conn.execute("UPDATE sessions SET mode = ? WHERE id = ?", (mode, session_id))
-
-
 def list_sessions() -> list[dict]:
     """All known sessions (named rows + any session that has exchanges), newest first."""
     conn = _connection()

lyra/modes.py

@@ -1,126 +0,0 @@
-"""Conversation modes — how a chat turn is framed and which tools are offered.
-
-A mode bundles three things: a *prompt card* (a system fragment injected each
-turn that tells Lyra how to behave right now), a *tool allow-list* (which of her
-tools she's handed this turn), and — implicitly, via the card — her behavioral
-register.
-
-The problem this solves: one persona + every tool offered every turn made her a
-wishy-washy companion during live poker ("I don't automatically log stack sizes,
-but...") when she should have silently logged and moved on. Modes let the same
-agent be a fast, act-first copilot at the table and her full reflective self
-otherwise — without two personas.
-
-v1 ships two modes:
-  - Talk (default): the companion. Journaling + read-only poker lookups.
-  - Cash: live cash-game copilot. Full live toolset, two-register behavior.
-
-Tournament is deliberately deferred. Strategy-RAG retrieval will later plug into
-Cash's *coaching register* (see the card) without changing this structure.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class Mode:
-    key: str               # stable id stored on the session row + sent by the UI
-    label: str             # short label for the UI switcher
-    card: str              # system prompt fragment injected per turn ("" = none)
-    tools: tuple[str, ...]  # tool names offered in this mode (must exist in tools.TOOLS)
-
-
-# Read-only poker lookups — safe in any mode, so "how am I running this year?",
-# "what do we have on Round Mike?", or "how'd my last few sessions go?" all work
-# even when we're just talking.
-_LOOKUPS = ("player_profile", "get_villain_file", "running_stats", "recent_sessions")
-
-# Always-available core tools (her own agency: journaling/notes).
-_BASE = ("journal_write", "note")
-
-# The full live cash-game toolset (incl. Brian's mental-game rituals).
-_CASH_TOOLS = _BASE + _LOOKUPS + (
-    "start_session", "add_buyin", "log_stack", "log_hand", "record_hand",
-    "add_read", "analyze_spot", "session_stats", "session_state", "end_session",
-    "generate_recap", "scar_note", "confidence_bank", "alligator_blood", "reset_ritual",
-)
-
-# Talk mode also gets start_session as the *entry point*: opening a session from a
-# normal chat auto-flips the session into Cash mode (see chat.respond).
-_TALK_TOOLS = _BASE + _LOOKUPS + ("start_session",)
-
-
-_CASH_CARD = """You are copiloting Brian's LIVE cash game right now — you're at the table with him, \
-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.
-
-• 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 \
-and be fully present — your real voice, warm and direct and his. Talk him down off tilt, keep \
-him engaged and disciplined through a card-dead stretch, actually walk the strategic spot with \
-him. Strategy and mental game get the real Lyra, not a clipped confirmation. Never clip these.
-
-Stacks and money are in dollars. For ANY equity / who's-ahead / outs / what-a-card-does \
-question, call analyze_spot and report its numbers — never eyeball board math. Keep the \
-session current as the night goes; you can pull session_stats or a player's profile whenever \
-it helps. When he's ready to leave, end_session, and write the recap if he wants it.
-
-Everything you log appears on Brian's live HUD (the Session view) — stack, live net, \
-hands, villains, the confidence bank, the scar notes, and whether Alligator Blood is on. \
-That HUD and you read the SAME data. So when he asks where he's at — his stack, his live \
-net, what's in the bank tonight, whether gator mode is on — call session_state and answer \
-from what it returns, never from memory. You can point him at the HUD too ("it's on your \
-Session screen"), but you can always just tell him.
-
-BRIAN'S RITUALS — his mental-game system. Run them, don't just reference them:
-• SCAR NOTE (scar_note) — a painful, instructive mistake to study. Log it when he punts, \
-gets over-attached, or leaks — and classify it honestly: punt (his error), cooler \
-(unavoidable), or standard (right play, bad result). That punt-vs-cooler line matters to him; \
-don't soften a punt into a cooler, and don't call a cooler a punt.
-• CONFIDENCE BANK (confidence_bank) — good PROCESS regardless of result: a disciplined fold, \
-clean value, catching a leak mid-hand, holding the line. Bank it when he earns it, ESPECIALLY \
-when the result didn't reward the good decision. This is how he stays steady.
-• ALLIGATOR BLOOD (alligator_blood) — his adversity state: hang around, refuse to die, don't \
-force miracles, make them beat you correctly. Turn it ON when he calls for it; SUGGEST it when \
-he's card-dead, short, stuck, or grinding a downswing. While it's on, coach him in that \
-register — tough, patient, no heroics — not bored or loose.
-• RESET (reset_ritual) — a circuit-breaker after a loss or tilt spike: a clean mental restart, \
-treat the rest of the night as a new session. Walk him through it when he's chasing or steaming, \
-then log it.
-These are the heart of the job. Use his language, hold the honest line, and let the rituals do \
-the work mentioning them naturally — never invent a scar or a confidence-bank entry that didn't happen."""
-
-
-TALK = Mode(
-    key="conversation",
-    label="Talk",
-    card="",  # the persona's default voice is the Talk register
-    tools=_TALK_TOOLS,
-)
-
-CASH = Mode(
-    key="poker_cash",
-    label="Cash",
-    card=_CASH_CARD,
-    tools=_CASH_TOOLS,
-)
-
-MODES: dict[str, Mode] = {m.key: m for m in (TALK, CASH)}
-DEFAULT = TALK.key
-
-
-def get(key: str | None) -> Mode:
-    """Resolve a mode key to a Mode, falling back to the default for None/unknown."""
-    return MODES.get(key or "", MODES[DEFAULT])
-
-
-def listing() -> list[dict]:
-    """[{key, label}] for the UI switcher."""
-    return [{"key": m.key, "label": m.label} for m in MODES.values()]

lyra/poker.py

@@ -98,30 +98,6 @@ CREATE TABLE IF NOT EXISTS player_observations (
     created_at TEXT NOT NULL
 );
 CREATE INDEX IF NOT EXISTS idx_pobs_player ON player_observations(player_id);
-
--- Stack-size log: one row per stack update Brian gives during a session. Lets the
--- HUD show current stack, live net while sitting, and a stack-over-time sparkline.
-CREATE TABLE IF NOT EXISTS poker_stack_log (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id INTEGER NOT NULL,
-    amount REAL NOT NULL,
-    created_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_stacklog_session ON poker_stack_log(session_id);
-
--- Mental-game rituals Brian developed (scar notes, confidence bank, alligator
--- blood, reset). Session-scoped events: capture entries (scar/confidence/reset)
--- carry text; the alligator state is the latest alligator_on/alligator_off event.
-CREATE TABLE IF NOT EXISTS poker_rituals (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id INTEGER NOT NULL,
-    kind TEXT NOT NULL,          -- scar | confidence | reset | alligator_on | alligator_off
-    content TEXT,
-    classification TEXT,         -- scar only: punt | cooler | standard
-    hand_id INTEGER,
-    created_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_rituals_session ON poker_rituals(session_id);
 """
 
 # Below this many observed hands, don't surface % stats (too small a sample).
@@ -205,43 +181,6 @@ def clear_all() -> dict:
     return counts
 
 
-def list_sessions(limit: int | None = None, include_review: bool = False) -> list[dict]:
-    """Past + live sessions (newest first), each with a hand count + recap flag.
-    Excludes the standing 'Hand Reviews' bucket unless include_review."""
-    sql = "SELECT * FROM poker_sessions"
-    if not include_review:
-        sql += " WHERE status != 'review'"
-    sql += " ORDER BY started_at DESC, id DESC"
-    if limit:
-        sql += f" LIMIT {int(limit)}"
-    rows = [dict(r) for r in _c().execute(sql).fetchall()]
-    for r in rows:
-        r["hands"] = _c().execute(
-            "SELECT COUNT(*) n FROM poker_hands WHERE session_id = ?", (r["id"],)
-        ).fetchone()["n"]
-        r["has_recap"] = bool(r.get("recap_md"))
-    return rows
-
-
-def delete_session(session_id: int) -> dict:
-    """Delete one session and its hands/reads/observations/stack/rituals. Leaves the
-    persistent villain file (poker_players) intact. Returns rows removed per table."""
-    conn = _c()
-    counts: dict[str, int] = {}
-    with conn:
-        for t in ("poker_hands", "player_observations", "player_reads",
-                  "poker_stack_log", "poker_rituals"):
-            counts[t] = conn.execute(
-                f"SELECT COUNT(*) n FROM {t} WHERE session_id = ?", (session_id,)
-            ).fetchone()["n"]
-            conn.execute(f"DELETE FROM {t} WHERE session_id = ?", (session_id,))
-        counts["poker_sessions"] = conn.execute(
-            "SELECT COUNT(*) n FROM poker_sessions WHERE id = ?", (session_id,)
-        ).fetchone()["n"]
-        conn.execute("DELETE FROM poker_sessions WHERE id = ?", (session_id,))
-    return counts
-
-
 def live_session() -> dict | None:
     """The current open session, if any."""
     r = _c().execute(
@@ -273,115 +212,6 @@ def add_buyin(amount: float, session_id: int | None = None) -> float:
     ).fetchone()["buy_in_total"])
 
 
-# --- 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)."""
-    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()),
-        )
-    return stack_state(sid)
-
-
-def current_stack(session_id: int | None = None) -> float | None:
-    """Most recently logged stack for a session, or None if none logged."""
-    sid = _resolve(session_id)
-    if sid is None:
-        return None
-    r = _c().execute(
-        "SELECT amount FROM poker_stack_log WHERE session_id = ? ORDER BY id DESC LIMIT 1",
-        (sid,),
-    ).fetchone()
-    return float(r["amount"]) if r else None
-
-
-def stack_log(session_id: int | None = None) -> list[dict]:
-    """Full stack history for a session (oldest first) — the sparkline series."""
-    sid = _resolve(session_id)
-    if sid is None:
-        return []
-    return [dict(r) for r in _c().execute(
-        "SELECT amount, created_at FROM poker_stack_log WHERE session_id = ? ORDER BY id",
-        (sid,),
-    ).fetchall()]
-
-
-def stack_state(session_id: int | None = None) -> dict:
-    """Current stack + buy-in + live net for a session (net None until a stack is logged)."""
-    sid = _resolve(session_id)
-    s = get_session(sid) if sid is not None else None
-    buy_in = float(s["buy_in_total"]) if s else 0.0
-    cur = current_stack(sid)
-    return {
-        "current": cur,
-        "buy_in": buy_in,
-        "net": (round(cur - buy_in, 2) if cur is not None else None),
-    }
-
-
-# --- mental-game rituals (scar notes / confidence bank / alligator blood / reset) ---
-
-RITUAL_CAPTURE = ("scar", "confidence", "reset")
-
-
-def log_ritual(kind: str, content: str | None = None, classification: str | None = None,
-               hand_id: int | None = None, session_id: int | None = None) -> int:
-    """Record a ritual event (a scar note, confidence-bank entry, reset, or an
-    alligator on/off toggle) against a session. Returns the row id."""
-    sid = _resolve(session_id)
-    if sid is None:
-        raise ValueError("no live session")
-    conn = _c()
-    with conn:
-        cur = conn.execute(
-            "INSERT INTO poker_rituals (session_id, kind, content, classification, hand_id, created_at) "
-            "VALUES (?, ?, ?, ?, ?, ?)",
-            (sid, kind, content, classification, hand_id, _now()),
-        )
-    return int(cur.lastrowid)
-
-
-def list_rituals(session_id: int | None = None,
-                 kinds: tuple[str, ...] | None = None) -> list[dict]:
-    """Ritual events for a session, oldest first; optionally filtered by kind."""
-    sid = _resolve(session_id)
-    if sid is None:
-        return []
-    sql = "SELECT * FROM poker_rituals WHERE session_id = ?"
-    params: list = [sid]
-    if kinds:
-        sql += " AND kind IN (%s)" % ",".join("?" * len(kinds))
-        params += list(kinds)
-    sql += " ORDER BY id"
-    return [dict(r) for r in _c().execute(sql, params).fetchall()]
-
-
-def set_alligator(on: bool, session_id: int | None = None) -> bool:
-    """Toggle Alligator Blood mode for the session. Returns the new state."""
-    log_ritual("alligator_on" if on else "alligator_off", session_id=session_id)
-    return bool(on)
-
-
-def alligator_active(session_id: int | None = None) -> bool:
-    """Whether Alligator Blood mode is currently ON (latest toggle wins)."""
-    sid = _resolve(session_id)
-    if sid is None:
-        return False
-    r = _c().execute(
-        "SELECT kind FROM poker_rituals WHERE session_id = ? "
-        "AND kind IN ('alligator_on', 'alligator_off') ORDER BY id DESC LIMIT 1",
-        (sid,),
-    ).fetchone()
-    return bool(r and r["kind"] == "alligator_on")
-
-
 def end_session(cash_out: float, mood: str | None = None,
                 session_id: int | None = None) -> dict:
     """Close a session: record cashout, compute net + hours. Returns the row."""
@@ -659,21 +489,6 @@ def _hand_line(h: dict) -> str:
     return " | ".join(str(b) for b in bits if b)
 
 
-_RITUAL_LABEL = {"scar": "Scar Note", "confidence": "Confidence Bank",
-                 "reset": "Reset", "alligator_on": "Alligator Blood ON",
-                 "alligator_off": "Alligator Blood OFF"}
-
-
-def _rituals_block(rituals: list[dict]) -> str:
-    lines = []
-    for r in rituals:
-        label = _RITUAL_LABEL.get(r["kind"], r["kind"])
-        cls = f" [{r['classification']}]" if r.get("classification") else ""
-        body = f": {r['content']}" if r.get("content") else ""
-        lines.append(f"- {label}{cls}{body}")
-    return "\n".join(lines)
-
-
 def generate_recap(session_id: int | None = None, backend: str | None = None) -> dict | None:
     """Generate Brian's .md recap from a session's structured data + conversation, store it."""
     backend = backend or "cloud"
@@ -685,7 +500,6 @@ def generate_recap(session_id: int | None = None, backend: str | None = None) ->
     reads = [dict(r) for r in _c().execute(
         "SELECT seat, note FROM player_reads WHERE session_id = ?", (sid,)).fetchall()]
     stats = session_stats(sid)
-    rituals = list_rituals(sid)
 
     convo = ""
     if s.get("chat_session_id"):
@@ -702,9 +516,6 @@ def generate_recap(session_id: int | None = None, backend: str | None = None) ->
         f"{stats.get('per_hour')}/hr | hands logged: {stats.get('hands_logged')} | tags: {stats.get('tags')}\n\n"
         "HANDS:\n" + ("\n".join("- " + _hand_line(h) for h in hands) or "(none logged)") + "\n\n"
         "READS:\n" + ("\n".join(f"- seat {r.get('seat')}: {r['note']}" for r in reads) or "(none)") + "\n\n"
-        "RITUALS (use these for the Scar Notes / Confidence Bank / Mental Game sections — "
-        "they are what actually happened, not to be invented):\n"
-        + (_rituals_block(rituals) or "(none logged)") + "\n\n"
         "CONVERSATION DURING SESSION:\n" + (convo or "(none captured)")
     )
     md = llm.complete(
@@ -941,89 +752,3 @@ def running_stats(stakes: str | None = None, venue: str | None = None,
         "per_hour": round(net / hours, 2) if hours else None,
         "by_stake": by_stake,
     }
-
-
-# --- live session HUD (everything tracked in the current session, for the UI) ---
-
-def _session_villains(sid: int) -> list[dict]:
-    """Players read this session, with their standing dossier fields."""
-    rows = _c().execute(
-        "SELECT p.name AS name, p.category AS category, p.tendencies AS tendencies, "
-        "p.adjustment AS adjustment, "
-        "(SELECT note FROM player_reads r2 WHERE r2.player_id = p.id "
-        " AND r2.session_id = ? ORDER BY r2.id DESC LIMIT 1) AS last_note "
-        "FROM poker_players p "
-        "WHERE p.id IN (SELECT DISTINCT player_id FROM player_reads "
-        "               WHERE session_id = ? AND player_id IS NOT NULL) "
-        "ORDER BY p.updated_at DESC",
-        (sid, sid),
-    ).fetchall()
-    return [dict(r) for r in rows]
-
-
-def hud(session_id: int | None = None) -> dict | None:
-    """Everything tracked in the current (or given) session, for the live HUD.
-
-    Returns None when there's no session to show. The shape is presentation-ready:
-    header, stack (with sparkline series + live net), hands, villains seen, her
-    notes from the session window, and session stats.
-    """
-    s = get_session(session_id) if session_id is not None else live_session()
-    if not s:
-        return None
-    sid = s["id"]
-    log = stack_log(sid)
-    state = stack_state(sid)
-
-    hands = [
-        {"id": h["id"], "position": h.get("position"), "hole_cards": h.get("hole_cards"),
-         "board": h.get("board"), "result": h.get("result"), "tag": h.get("tag"),
-         "at": h.get("at")}
-        for h in list_hands(sid)
-    ]
-
-    # Notes she jotted during this session: journal/note entries since it started.
-    started = s.get("started_at") or ""
-    notes = [
-        {"created_at": j["created_at"], "kind": j["kind"], "content": j["content"]}
-        for j in memory.list_journal(kinds=("note", "journal"))
-        if (j["created_at"] or "") >= started
-    ][:20]
-
-    stats = session_stats(sid)
-    # Context: how Brian runs at these stakes overall (closed sessions).
-    ctx = running_stats(stakes=s.get("stakes")) if s.get("stakes") else {}
-
-    rituals = list_rituals(sid)
-    by_kind = lambda k: [  # noqa: E731
-        {"content": r["content"], "classification": r["classification"],
-         "hand_id": r["hand_id"], "at": r["created_at"]}
-        for r in rituals if r["kind"] == k
-    ]
-
-    return {
-        "session": {
-            "id": sid, "venue": s.get("venue"), "stakes": s.get("stakes"),
-            "game": s.get("game"), "format": s.get("format"),
-            "status": s.get("status"), "started_at": s.get("started_at"),
-            "buy_in_total": s.get("buy_in_total"),
-        },
-        "stack": {
-            "current": state["current"], "buy_in": state["buy_in"], "net": state["net"],
-            "log": log,
-        },
-        "hands": hands,
-        "villains": _session_villains(sid),
-        "notes": notes,
-        "rituals": {
-            "alligator": alligator_active(sid),
-            "scars": by_kind("scar"),
-            "confidence": by_kind("confidence"),
-            "resets": by_kind("reset"),
-        },
-        "stats": {
-            "hands_logged": stats.get("hands_logged", 0),
-            "tags": stats.get("tags", {}),
-            "context_per_hour": ctx.get("per_hour"),
-        },
-    }

lyra/summary.py

@@ -10,7 +10,6 @@ big imported conversation doesn't blow the local model's context window.
 from __future__ import annotations
 
 import sys
-import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
@@ -21,15 +20,8 @@ _RETRIES = 4
 
 # Re-summarize a session once it has accumulated this many new raw exchanges.
 SUMMARIZE_AFTER = 20
-# Transcript budget per LLM call; longer sessions are chunked + merged. Cloud has
-# a large context window; the local llama.cpp/Ollama servers have small ones, so a
-# 24k-char chunk overflows them ("Context size has been exceeded") — keep local small.
+# Transcript budget per LLM call; longer sessions are chunked + merged.
 MAX_TRANSCRIPT_CHARS = 24000
-LOCAL_TRANSCRIPT_CHARS = 8000
-
-
-def _budget(backend: Backend) -> int:
-    return MAX_TRANSCRIPT_CHARS if backend == "cloud" else LOCAL_TRANSCRIPT_CHARS
 
 _PROMPT = """You are compacting a conversation into a long-term memory record \
 (not replying to anyone). Write a concise gist of the session below: what was \
@@ -74,14 +66,11 @@ def _summarize_text(text: str, backend: Backend) -> str:
 
 
 def _summarize_transcript(transcript: str, backend: Backend) -> str:
-    """Transcript -> gist (LLM only, no DB). Chunks + merges if oversized, and
-    recurses so even the merged partials never exceed the backend's window."""
-    budget = _budget(backend)
-    if len(transcript) <= budget:
+    """Transcript -> gist (LLM only, no DB). Chunks + merges if oversized."""
+    if len(transcript) <= MAX_TRANSCRIPT_CHARS:
         return _summarize_text(transcript, backend)
-    partials = [_summarize_text(c, backend) for c in _chunk(transcript, budget)]
-    merged = "Partial summaries to merge:\n\n" + "\n\n".join(partials)
-    return _summarize_transcript(merged, backend)
+    partials = [_summarize_text(c, backend) for c in _chunk(transcript, MAX_TRANSCRIPT_CHARS)]
+    return _summarize_text("Partial summaries to merge:\n\n" + "\n\n".join(partials), backend)
 
 
 def summarize_session(session_id: str, backend: Backend | None = None) -> str | None:
@@ -102,32 +91,6 @@ def maybe_summarize(session_id: str, backend: Backend | None = None) -> None:
         summarize_session(session_id, backend=backend)
 
 
-_inflight: set[str] = set()
-_inflight_lock = threading.Lock()
-
-
-def maybe_summarize_async(session_id: str, backend: Backend | None = None) -> None:
-    """Run maybe_summarize off the chat turn's critical path. Consolidation is
-    background maintenance — it must never stall the reply or surface an error to
-    the user (a slow/oversized local model would otherwise block the turn). At most
-    one summary per session runs at a time."""
-    with _inflight_lock:
-        if session_id in _inflight:
-            return
-        _inflight.add(session_id)
-
-    def _run() -> None:
-        try:
-            maybe_summarize(session_id, backend=backend)
-        except Exception as exc:
-            logbus.log("error", "summary skipped", session=session_id, error=str(exc)[:120])
-        finally:
-            with _inflight_lock:
-                _inflight.discard(session_id)
-
-    threading.Thread(target=_run, daemon=True, name="summarize").start()
-
-
 def summarize_all(
     backend: Backend | None = None, limit: int | None = None, workers: int = 8
 ) -> dict:

lyra/tools.py

@@ -104,64 +104,6 @@ def _add_buyin(args: dict, ctx: dict) -> str:
     return f"Added {args.get('amount')}. Total in this session: {total:g}."
 
 
-def _log_stack(args: dict, ctx: dict) -> str:
-    try:
-        amount = float(args.get("amount"))
-    except (TypeError, ValueError):
-        return "Give me a number for the stack."
-    try:
-        st = poker.log_stack(amount)
-    except ValueError:
-        return "No live session — start one first, then I'll track your stack."
-    net = st.get("net")
-    return f"Stack ${amount:g} logged" + (f" (net {net:+.0f})." if net is not None else ".")
-
-
-def _scar_note(args: dict, ctx: dict) -> str:
-    content = (args.get("content") or "").strip()
-    if not content:
-        return "Nothing to log — give me the scar."
-    cls = (args.get("classification") or "").strip().lower() or None
-    if cls and cls not in ("punt", "cooler", "standard"):
-        cls = None
-    try:
-        poker.log_ritual("scar", content=content, classification=cls,
-                         hand_id=args.get("hand_id"))
-    except ValueError:
-        return "No live session — start one and I'll keep the scar notes."
-    return f"Scar note logged{f' ({cls})' if cls else ''}."
-
-
-def _confidence_bank(args: dict, ctx: dict) -> str:
-    content = (args.get("content") or "").strip()
-    if not content:
-        return "Nothing to bank — tell me the good process."
-    try:
-        poker.log_ritual("confidence", content=content, hand_id=args.get("hand_id"))
-    except ValueError:
-        return "No live session — start one and I'll run the confidence bank."
-    return "Banked. 💰"
-
-
-def _alligator_blood(args: dict, ctx: dict) -> str:
-    on = bool(args.get("on", True))
-    try:
-        poker.set_alligator(on)
-    except ValueError:
-        return "No live session to set that on."
-    return ("🐊 Alligator Blood ON — hang around, refuse to die, no forced miracles."
-            if on else "Alligator Blood off. Back to standard register.")
-
-
-def _reset_ritual(args: dict, ctx: dict) -> str:
-    content = (args.get("content") or "").strip() or None
-    try:
-        poker.log_ritual("reset", content=content)
-    except ValueError:
-        return "No live session to reset."
-    return "Reset logged. Clean slate — this is a new session in your head."
-
-
 def _log_hand(args: dict, ctx: dict) -> str:
     fields = {k: args.get(k) for k in poker._HAND_FIELDS if args.get(k) not in (None, "")}
     hid = poker.log_hand(**fields)
@@ -187,29 +129,6 @@ def _end_session(args: dict, ctx: dict) -> str:
     return f"Session #{s['id']} closed — net {s['net']:+.0f} over {s['hours']}h{hourly}."
 
 
-def _session_state(args: dict, ctx: dict) -> str:
-    h = poker.hud()
-    if not h:
-        return "No live session right now."
-    s, st, r = h["session"], h["stack"], h["rituals"]
-    L = [f"{s.get('stakes') or '?'} {s.get('game') or ''} @ {s.get('venue') or '?'} "
-         f"— {h['stats']['hands_logged']} hands logged"]
-    if st.get("current") is not None:
-        L.append(f"Stack ${st['current']:g} (in {st['buy_in']:g}, live net {st['net']:+.0f})")
-    else:
-        L.append(f"Stack not logged yet (in {st['buy_in']:g})")
-    L.append("🐊 Alligator Blood is ON" if r["alligator"] else "Alligator Blood: off")
-    if r["confidence"]:
-        L.append("Confidence bank: " + " | ".join(c["content"] for c in r["confidence"][-4:]))
-    if r["scars"]:
-        L.append("Scar notes: " + " | ".join(
-            sc["content"] + (f" [{sc['classification']}]" if sc.get("classification") else "")
-            for sc in r["scars"][-4:]))
-    if r["resets"]:
-        L.append(f"{len(r['resets'])} reset(s) this session")
-    return "\n".join(L)
-
-
 def _session_stats(args: dict, ctx: dict) -> str:
     st = poker.session_stats()
     if not st:
@@ -221,27 +140,6 @@ def _session_stats(args: dict, ctx: dict) -> str:
             f"{st['hands_logged']} hands logged (tags: {tags}).")
 
 
-def _recent_sessions(args: dict, ctx: dict) -> str:
-    try:
-        n = int(args.get("limit") or 8)
-    except (TypeError, ValueError):
-        n = 8
-    rows = poker.list_sessions(limit=n)
-    if not rows:
-        return "No sessions logged yet."
-    out = []
-    for s in rows:
-        net = s.get("net")
-        netstr = (f"{net:+.0f}" if net is not None
-                  else "live" if s.get("status") == "live" else "—")
-        hrs = f", {s['hours']:g}h" if s.get("hours") else ""
-        recap = " · recap" if s.get("has_recap") else ""
-        out.append(f"#{s['id']} {(s.get('started_at') or '')[:10]} "
-                   f"{s.get('stakes') or '?'} {s.get('game') or ''} @ {s.get('venue') or '?'} "
-                   f"— net {netstr}{hrs} ({s.get('hands', 0)} hands){recap}")
-    return "\n".join(out)
-
-
 def _running_stats(args: dict, ctx: dict) -> str:
     rs = poker.running_stats(stakes=args.get("stakes"), venue=args.get("venue"),
                              game=args.get("game"), since=args.get("since"))
@@ -370,46 +268,6 @@ TOOLS.update({
     "add_buyin": {"handler": _add_buyin, "spec": _f(
         "add_buyin", "Record a rebuy / additional buy-in in the live session.",
         {"amount": {**_N, "description": "Amount added"}}, ["amount"])},
-    "log_stack": {"handler": _log_stack, "spec": _f(
-        "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"}},
-        ["amount"])},
-    "scar_note": {"handler": _scar_note, "spec": _f(
-        "scar_note",
-        "Log a SCAR NOTE — a painful or instructive mistake to study later. Use when "
-        "Brian punts, gets too attached, or makes a leak — or when he flags one. "
-        "Classify honestly: 'punt' (his error), 'cooler' (unavoidable), or 'standard' "
-        "(correct play, bad result). The punt-vs-cooler distinction matters to him.",
-        {"content": {**_S, "description": "What happened and the lesson, in Brian's terms"},
-         "classification": {**_S, "description": "punt | cooler | standard"},
-         "hand_id": {**_N, "description": "Linked hand id, if this scar is a logged hand"}},
-        ["content"])},
-    "confidence_bank": {"handler": _confidence_bank, "spec": _f(
-        "confidence_bank",
-        "Log a CONFIDENCE BANK entry — good PROCESS regardless of result: a disciplined "
-        "laydown, clean value bet, catching a leak in real time, sticking to the plan. "
-        "Bank it when he does something right, especially when the result didn't reward it.",
-        {"content": {**_S, "description": "The disciplined / good-process play to bank"},
-         "hand_id": {**_N, "description": "Linked hand id, if applicable"}},
-        ["content"])},
-    "alligator_blood": {"handler": _alligator_blood, "spec": _f(
-        "alligator_blood",
-        "Toggle ALLIGATOR BLOOD mode — Brian's adversity state: hang around, refuse to "
-        "die, don't force miracles, make opponents beat him correctly. Turn it ON when he "
-        "invokes it, or SUGGEST it (then turn on if he agrees) when he's card-dead, short, "
-        "stuck, or grinding through a downswing. Turn OFF on reset or when he's back in rhythm.",
-        {"on": {"type": "boolean", "description": "true to engage, false to stand down"}},
-        [])},
-    "reset_ritual": {"handler": _reset_ritual, "spec": _f(
-        "reset_ritual",
-        "Log a RESET — a deliberate mental circuit-breaker after a loss or tilt spike, "
-        "treating the rest of the night as a fresh start (the stats stay continuous). "
-        "Use when he resets, or when you've talked him through one.",
-        {"content": {**_S, "description": "Optional note on what prompted the reset"}},
-        [])},
     "log_hand": {"handler": _log_hand, "spec": _f(
         "log_hand",
         "Log a hand in the live session. All fields optional — capture whatever Brian gives you, even terse.",
@@ -446,20 +304,6 @@ TOOLS.update({
     "session_stats": {"handler": _session_stats, "spec": _f(
         "session_stats", "Get money + hand summary for the current/most-recent session.",
         {}, [])},
-    "session_state": {"handler": _session_state, "spec": _f(
-        "session_state",
-        "Read back the CURRENT live-session state — the same data Brian sees on his HUD: "
-        "stack, live net, whether Alligator Blood is on, and the scar notes / "
-        "confidence-bank entries so far. Use whenever he asks where he's at, what's in "
-        "the bank, his stack or net, or if gator mode is on — answer from THIS, not memory.",
-        {}, [])},
-    "recent_sessions": {"handler": _recent_sessions, "spec": _f(
-        "recent_sessions",
-        "List Brian's recent poker sessions — date, stakes, venue, net, hours, hand "
-        "count. Use when he asks about past sessions, how recent ones went, or to find "
-        "a session to review. Answer from this, not memory.",
-        {"limit": {**_N, "description": "How many recent sessions (default 8)"}},
-        [])},
     "running_stats": {"handler": _running_stats, "spec": _f(
         "running_stats",
         "Cumulative results across closed sessions (net, $/hr, by stake). Optionally filter.",
@@ -509,16 +353,9 @@ TOOLS.update({
 })
 
 
-def specs(allow=None) -> list[dict]:
-    """OpenAI-format tool definitions to offer the model.
-
-    `allow` (an iterable of tool names, e.g. a mode's allow-list) restricts the
-    set; None means every tool. Unknown names in `allow` are ignored.
-    """
-    if allow is None:
+def specs() -> list[dict]:
+    """OpenAI-format tool definitions to offer the model."""
     return [t["spec"] for t in TOOLS.values()]
-    allow = set(allow)
-    return [t["spec"] for name, t in TOOLS.items() if name in allow]
 
 
 def dispatch(name: str, arguments, ctx: dict | None = None) -> str:

lyra/web/gen_icons.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""Generate Lyra PWA icons with no third-party deps (pure stdlib PNG writer).
-
-Design: RTO warm/low-glow — near-black field, a soft orange ambient glow, and a
-luminous gold-orange ring (the "orb/portal"). iOS masks corners itself, so icons
-are full-bleed squares. Run from anywhere; writes PNGs into ./static.
-"""
-import math
-import os
-import struct
-import zlib
-
-HERE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
-
-BG = (7, 7, 7)            # #070707
-ORANGE = (255, 122, 0)    # #ff7a00 accent
-GOLD = (255, 179, 71)     # #ffb347 hot core
-
-
-def _png(width, height, rgb_rows):
-    def chunk(tag, data):
-        return (struct.pack(">I", len(data)) + tag + data
-                + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF))
-
-    raw = bytearray()
-    for row in rgb_rows:
-        raw.append(0)  # filter type 0 (None)
-        raw.extend(row)
-    ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)  # 8-bit RGB
-    return (b"\x89PNG\r\n\x1a\n"
-            + chunk(b"IHDR", ihdr)
-            + chunk(b"IDAT", zlib.compress(bytes(raw), 9))
-            + chunk(b"IEND", b""))
-
-
-def render(n):
-    c = (n - 1) / 2.0
-    sigma_glow = n * 0.30
-    ring_r = n * 0.30
-    ring_w = n * 0.050
-    core_sigma = n * 0.11
-    rows = []
-    for y in range(n):
-        row = bytearray()
-        for x in range(n):
-            dx, dy = x - c, y - c
-            d = math.hypot(dx, dy)
-            r, g, b = BG
-            # ambient orange glow
-            glow = math.exp(-(d * d) / (2 * sigma_glow * sigma_glow)) * 0.50
-            # soft hot core
-            core = math.exp(-(d * d) / (2 * core_sigma * core_sigma)) * 0.45
-            # luminous ring
-            rr = d - ring_r
-            ring = math.exp(-(rr * rr) / (2 * ring_w * ring_w))
-            r += ORANGE[0] * glow + GOLD[0] * (ring + core)
-            g += ORANGE[1] * glow + GOLD[1] * (ring + core)
-            b += ORANGE[2] * glow + GOLD[2] * (ring + core)
-            row += bytes((min(255, int(r)), min(255, int(g)), min(255, int(b))))
-        rows.append(row)
-    return rows
-
-
-def write(name, n):
-    rows = render(n)
-    with open(os.path.join(HERE, name), "wb") as f:
-        f.write(_png(n, n, rows))
-    print(f"wrote {name} ({n}x{n})")
-
-
-if __name__ == "__main__":
-    write("icon-512.png", 512)
-    write("icon-192.png", 192)
-    write("apple-touch-icon.png", 180)
-    write("icon-maskable-512.png", 512)

lyra/web/server.py

@@ -18,7 +18,7 @@ from fastapi import FastAPI, Request, Response
 from fastapi.responses import FileResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 
-from lyra import chat, logbus, memory, modes, poker, self_state, summary
+from lyra import chat, logbus, memory, poker, self_state, summary
 from lyra.llm import Backend
 
 
@@ -85,49 +85,6 @@ def create_app() -> FastAPI:
         gist = await asyncio.to_thread(summary.summarize_session, session_id)
         return {"ok": gist is not None, "summary": gist}
 
-    @app.get("/modes")
-    async def list_modes() -> dict:
-        """Available conversation modes, for the UI switcher."""
-        return {"modes": modes.listing(), "default": modes.DEFAULT}
-
-    @app.get("/sessions/{session_id}/mode")
-    async def get_mode(session_id: str) -> dict:
-        return {"mode": memory.get_session_mode(session_id) or modes.DEFAULT}
-
-    @app.post("/sessions/{session_id}/mode")
-    async def set_mode(session_id: str, request: Request) -> dict:
-        body = await request.json()
-        mode = body.get("mode") or modes.DEFAULT
-        memory.set_session_mode(session_id, mode)
-        logbus.log("info", "mode set", session=session_id, mode=mode)
-        return {"ok": True, "mode": mode}
-
-    @app.get("/session")
-    async def session_hud_page() -> FileResponse:
-        """Live session HUD — stack, hands, villains, notes for the open session."""
-        return FileResponse(str(_STATIC / "session.html"))
-
-    @app.get("/session/data")
-    async def session_hud_data() -> dict:
-        """The current live session's HUD bundle (or {session: None} if none open)."""
-        bundle = await asyncio.to_thread(poker.hud)
-        return bundle or {"session": None}
-
-    @app.get("/history")
-    async def history_page() -> FileResponse:
-        """Browsable list of past poker sessions."""
-        return FileResponse(str(_STATIC / "history.html"))
-
-    @app.get("/history/data")
-    async def history_data(limit: int = 100, include_review: bool = False) -> dict:
-        return {"sessions": poker.list_sessions(limit=limit, include_review=include_review)}
-
-    @app.delete("/history/{session_id}")
-    async def history_delete(session_id: int) -> dict:
-        removed = await asyncio.to_thread(poker.delete_session, session_id)
-        logbus.log("info", "poker session deleted", id=session_id, removed=removed)
-        return {"ok": True, "removed": removed}
-
     @app.post("/v1/chat/completions")
     async def chat_completions(request: Request) -> dict:
         body = await request.json()
@@ -137,8 +94,6 @@ def create_app() -> FastAPI:
 
         model_override = body.get("model") or None
         memory.ensure_session(session_id)
-        if body.get("mode"):
-            memory.set_session_mode(session_id, body["mode"])
         try:
             reply = await asyncio.to_thread(chat.respond, session_id, user_msg, backend, model_override)
         except Exception as exc:
@@ -156,47 +111,6 @@ def create_app() -> FastAPI:
             ],
         }
 
-    @app.post("/v1/chat/stream")
-    async def chat_stream(request: Request) -> StreamingResponse:
-        """Server-Sent Events: stream Lyra's reply token-by-token.
-
-        `chat.respond_stream` is a blocking generator (httpx/openai), so it runs in
-        a worker thread and bridges chunks to this async generator via a queue.
-        """
-        body = await request.json()
-        session_id = body.get("sessionId") or "default"
-        backend = _backend_for(body.get("backend"))
-        user_msg = _last_user_message(body.get("messages", []))
-        model_override = body.get("model") or None
-        memory.ensure_session(session_id)
-        if body.get("mode"):
-            memory.set_session_mode(session_id, body["mode"])
-
-        async def gen():
-            loop = asyncio.get_running_loop()
-            q: asyncio.Queue = asyncio.Queue()
-            done = object()
-
-            def produce():
-                try:
-                    for event in chat.respond_stream(session_id, user_msg, backend, model_override):
-                        loop.call_soon_threadsafe(q.put_nowait, event)
-                except Exception as exc:  # surface to the client stream, don't hang
-                    logbus.log("error", "chat stream failed", session=session_id, error=str(exc))
-                    loop.call_soon_threadsafe(q.put_nowait, ("error", str(exc)))
-                finally:
-                    loop.call_soon_threadsafe(q.put_nowait, done)
-
-            loop.run_in_executor(None, produce)
-            while True:
-                item = await q.get()
-                if item is done:
-                    break
-                ev, payload = item
-                yield f"data: {json.dumps({'type': ev, 'payload': payload})}\n\n"
-
-        return StreamingResponse(gen(), media_type="text/event-stream")
-
     @app.get("/logs")
     async def logs_page() -> FileResponse:
         """Full-page, mobile-friendly live log viewer (separate from the chat UI)."""

lyra/web/static/history.html

@@ -1,104 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
-  <meta name="theme-color" content="#070707" />
-  <title>Lyra — Sessions</title>
-  <style>
-    :root{--bg:#070707;--bg-elev:#0e0e0e;--bg-line:#141414;--border:#2a1d12;--text:#e8e8e8;
-      --fade:#8a8a8a;--accent:#ff7a00;--good:#8fd694;--low:#ff6b6b;--mid:#ffb347;}
-    *{box-sizing:border-box;}
-    html,body{margin:0;min-height:100%;background:var(--bg);color:var(--text);
-      font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;-webkit-text-size-adjust:100%;}
-    header{position:sticky;top:0;z-index:10;background:var(--bg-elev);border-bottom:1px solid var(--border);
-      padding:env(safe-area-inset-top) 14px 0;}
-    .topbar{display:flex;align-items:center;gap:10px;padding:13px 0;}
-    .topbar h1{font-size:1.05rem;margin:0;font-weight:600;}
-    .topbar a.back{color:var(--accent);text-decoration:none;font-size:.92rem;}
-    .count{margin-left:auto;color:var(--fade);font-size:.8rem;}
-    main{max-width:640px;margin:0 auto;padding:12px 12px 40px;}
-    .summary{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:12px;}
-    .pill{font-size:.8rem;color:var(--fade);background:var(--bg-elev);border:1px solid var(--border);
-      border-radius:999px;padding:4px 11px;} .pill b{color:var(--text);}
-    .row{display:flex;align-items:center;gap:12px;background:var(--bg-elev);border:1px solid var(--border);
-      border-radius:10px;padding:10px 12px;margin-bottom:8px;}
-    .row .body{flex:1;min-width:0;text-decoration:none;color:var(--text);}
-    .row .body:active{opacity:.7;}
-    .ln1{font-size:.95rem;} .ln1 .live{color:var(--accent);font-size:.7rem;border:1px solid var(--accent);
-      border-radius:999px;padding:0 6px;margin-left:6px;text-transform:uppercase;letter-spacing:.4px;}
-    .ln2{font-size:.76rem;color:var(--fade);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
-    .net{flex:none;font-variant-numeric:tabular-nums;font-weight:700;}
-    .net.up{color:var(--good);} .net.down{color:var(--low);} .net.flat{color:var(--fade);}
-    .del{flex:none;background:none;border:1px solid var(--border);color:var(--fade);border-radius:8px;
-      padding:6px 9px;cursor:pointer;-webkit-tap-highlight-color:transparent;font-size:.9rem;}
-    .del:active{background:#3a1414;color:var(--low);border-color:var(--low);}
-    .empty{color:var(--fade);text-align:center;padding:46px 16px;}
-  </style>
-</head>
-<body>
-  <header>
-    <div class="topbar">
-      <h1>📚 Sessions</h1>
-      <a class="back" href="/">← Chat</a>
-      <a class="back" href="/session">🎬 Live</a>
-      <span class="count" id="count"></span>
-    </div>
-  </header>
-  <main id="root"><p class="empty">Loading…</p></main>
-
-  <script>
-    function esc(s){const d=document.createElement('div');d.textContent=s==null?'':String(s);return d.innerHTML;}
-    function money(v){if(v==null)return '—';const n=Number(v);return (n>0?'+$':n<0?'-$':'$')+Math.abs(n).toLocaleString();}
-    function netClass(v){return v==null?'flat':v>0?'up':v<0?'down':'flat';}
-
-    async function del(id, label){
-      if(!confirm(`Delete session ${label}? This removes its hands, reads, stacks and rituals. Can't be undone.`)) return;
-      try{
-        const r=await fetch(`/history/${id}`,{method:'DELETE'});
-        if(!r.ok) throw new Error('HTTP '+r.status);
-        load();
-      }catch(e){alert('Delete failed: '+e.message);}
-    }
-
-    async function load(){
-      const root=document.getElementById('root');
-      try{
-        const r=await fetch('/history/data',{cache:'no-store'});
-        const sessions=(await r.json()).sessions||[];
-        document.getElementById('count').textContent=`${sessions.length} session${sessions.length===1?'':'s'}`;
-        if(!sessions.length){root.innerHTML='<p class="empty">No sessions yet. Start one from chat in ♠ Cash mode.</p>';return;}
-
-        const closed=sessions.filter(s=>s.net!=null);
-        const totNet=closed.reduce((a,s)=>a+(s.net||0),0);
-        const totHrs=closed.reduce((a,s)=>a+(s.hours||0),0);
-        const summary=`<div class="summary">
-          <span class="pill"><b>${sessions.length}</b> sessions</span>
-          <span class="pill">net <b>${money(totNet)}</b></span>
-          ${totHrs?`<span class="pill"><b>${totHrs.toFixed(1)}h</b></span>`:''}
-          ${totHrs?`<span class="pill">${money(Math.round(totNet/totHrs))}/hr</span>`:''}
-        </div>`;
-
-        root.innerHTML=summary+sessions.map(s=>{
-          const title=[s.stakes,s.game].filter(Boolean).join(' ')||'Session';
-          const live=s.status==='live'?'<span class="live">live</span>':'';
-          const date=(s.started_at||'').slice(0,10);
-          const meta=[date,s.venue,`${s.hands} hand${s.hands===1?'':'s'}`,
-                      s.hours?`${(+s.hours).toFixed(1)}h`:''].filter(Boolean).join(' · ');
-          const href=s.has_recap?`/recap/${s.id}`:`/session`;
-          const net=s.net!=null?money(s.net):(s.status==='live'?'live':'—');
-          return `<div class="row">
-            <a class="body" href="${href}">
-              <div class="ln1">${esc(title)} <span style="color:var(--fade)">@ ${esc(s.venue||'?')}</span>${live}</div>
-              <div class="ln2">${esc(meta)}${s.has_recap?' · recap ✓':''}</div>
-            </a>
-            <span class="net ${netClass(s.net)}">${net}</span>
-            <button class="del" title="Delete session" onclick="del(${s.id}, '#${s.id} ${esc(title)}')">🗑</button>
-          </div>`;
-        }).join('');
-      }catch(e){root.innerHTML='<p class="empty">Couldn\'t load sessions.</p>';}
-    }
-    load();
-  </script>
-</body>
-</html>

lyra/web/static/index.html

@@ -5,14 +5,10 @@
   <title>Lyra Core Chat</title>
   <link rel="stylesheet" href="style.css" />
   <!-- PWA -->
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
   <meta name="mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
-  <meta name="apple-mobile-web-app-title" content="Lyra" />
-  <meta name="theme-color" content="#070707" />
-  <link rel="apple-touch-icon" href="apple-touch-icon.png" />
-  <link rel="icon" type="image/png" href="icon-192.png" />
   <link rel="manifest" href="manifest.json" />
 
 </head>
@@ -25,8 +21,8 @@
     <div class="mobile-menu-section">
       <h4>Mode</h4>
       <select id="mobileMode">
-        <option value="conversation">💬 Talk</option>
-        <option value="poker_cash">♠ Cash</option>
+        <option value="standard">Standard</option>
+        <option value="cortex">Cortex</option>
       </select>
     </div>
 
@@ -39,11 +35,11 @@
 
     <div class="mobile-menu-section">
       <h4>Actions</h4>
-      <button id="mobileSessionBtn">🎬 Session HUD</button>
-      <button id="mobileHistoryBtn">📚 Past Sessions</button>
       <button id="mobileThinkingStreamBtn">📜 Live Log (inline)</button>
       <button id="mobileFullLogBtn">⛶ Full Log</button>
+      <button id="mobileMindBtn">🧠 Read Her Mind</button>
       <button id="mobileJournalBtn">📔 Journal</button>
+      <button id="mobileHandsBtn">🃏 Hands</button>
       <button id="mobileSettingsBtn">⚙ Settings</button>
       <button id="mobileToggleThemeBtn">🌙 Toggle Theme</button>
       <button id="mobileForceReloadBtn">🔄 Force Reload</button>
@@ -59,13 +55,10 @@
         <span></span>
         <span></span>
       </button>
-      <span class="brand">Lyra</span>
-      <span class="brand-dot" id="brandDot" title="Relay status"></span>
-      <button class="mode-badge" id="modeBadge" type="button" title="Tap to toggle Talk / Cash mode">💬 Talk</button>
       <label for="mode">Mode:</label>
       <select id="mode">
-        <option value="conversation">💬 Talk</option>
-        <option value="poker_cash">♠ Cash</option>
+        <option value="standard">Standard</option>
+        <option value="cortex">Cortex</option>
       </select>
       <button id="settingsBtn" style="margin-left: auto;">⚙ Settings</button>
       <div id="theme-toggle">
@@ -81,8 +74,6 @@
       <button id="renameSessionBtn">✏️ Rename</button>
       <button id="thinkingStreamBtn" title="Show live activity log">📜 Live Log</button>
       <a id="fullLogBtn" href="/logs" target="_blank" rel="noopener" title="Open the full-page log" role="button">⛶ Full Log</a>
-      <a id="sessionBtn" href="/session" target="_blank" rel="noopener" title="Live session HUD" role="button">🎬 Session</a>
-      <a id="historyBtn" href="/history" target="_blank" rel="noopener" title="Past sessions" role="button">📚 Sessions</a>
       <a id="mindBtn" href="/self" target="_blank" rel="noopener" title="Read her mind — Lyra's current self-state" role="button">🧠 Mind</a>
       <a id="handsBtn" href="/hands" target="_blank" rel="noopener" title="Recorded poker hands" role="button">🃏 Hands</a>
     </div>
@@ -116,18 +107,9 @@
 
     <!-- Input box -->
     <div id="input">
-      <textarea id="userInput" rows="1" placeholder="Type a message…" autofocus></textarea>
-      <button id="sendBtn" aria-label="Send" title="Send (or ⌘/Ctrl+Enter)">↑</button>
+      <input id="userInput" type="text" placeholder="Type a message..." autofocus />
+      <button id="sendBtn">Send</button>
     </div>
-
-    <!-- Bottom tab bar (mobile only; hides while the keyboard is open) -->
-    <nav id="tabbar" aria-label="Primary navigation">
-      <a class="tab active" href="/" aria-current="page"><span class="ti">💬</span><span class="tl">Chat</span></a>
-      <a class="tab" href="/session"><span class="ti">🎬</span><span class="tl">Session</span></a>
-      <a class="tab" href="/hands"><span class="ti">🃏</span><span class="tl">Hands</span></a>
-      <a class="tab" href="/self"><span class="ti">🧠</span><span class="tl">Mind</span></a>
-      <button class="tab" id="moreTab" type="button"><span class="ti">⋯</span><span class="tl">More</span></button>
-    </nav>
   </div>
 
   <!-- Settings Modal (outside chat container) -->
@@ -192,7 +174,6 @@
   <script>
     const RELAY_BASE = "";  // same-origin: served by lyra.web.server
     const API_URL = `${RELAY_BASE}/v1/chat/completions`;
-    const STREAM_URL = `${RELAY_BASE}/v1/chat/stream`;
 
 	function generateSessionId() {
       return "sess-" + Math.random().toString(36).substring(2, 10);
@@ -287,8 +268,6 @@
       if (!msg) return;
       inputEl.value = "";
 
-      autoGrow(inputEl);  // collapse the box back to one line after clearing
-
       addMessage("user", msg);
       history.push({ role: "user", content: msg });
 	  await saveSession(); // ✅ persist both user + assistant messages
@@ -306,10 +285,6 @@
       // Which chat backend to use (local Ollama vs cloud OpenAI).
       let backend = localStorage.getItem("standardModeBackend") || "local";
 
-      // Cash mode is useless without tools, and tools only fire on cloud — so a
-      // live poker session forces the cloud backend regardless of the saved pick.
-      if (mode === "poker_cash") backend = "cloud";
-
       const body = {
         mode: mode,
         messages: history,
@@ -327,107 +302,21 @@
         body.model = cloudModel;
       }
 
-      // Stream the reply token-by-token (SSE). Fall back to the blocking
-      // endpoint only if nothing streamed (e.g. streaming unavailable).
-      const div = createAssistantBubble();
-      let full = "";
-      try {
-        const resp = await fetch(STREAM_URL, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body)
-        });
-        if (!resp.ok || !resp.body) throw new Error("HTTP " + resp.status);
-
-        const reader = resp.body.getReader();
-        const decoder = new TextDecoder();
-        let buf = "";
-        for (;;) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          buf += decoder.decode(value, { stream: true });
-          let i;
-          while ((i = buf.indexOf("\n\n")) !== -1) {
-            const frame = buf.slice(0, i).trim();
-            buf = buf.slice(i + 2);
-            if (!frame.startsWith("data:")) continue;
-            let evt;
-            try { evt = JSON.parse(frame.slice(5).trim()); } catch (e) { continue; }
-            if (evt.type === "delta") {
-              full += evt.payload;
-              updateAssistantBubble(div, full);
-            } else if (evt.type === "done") {
-              if (evt.payload) full = evt.payload;
-            } else if (evt.type === "error") {
-              throw new Error(evt.payload);
-            }
-          }
-        }
-      } catch (err) {
-        if (!full) {
-          div.remove();
       try {
         const resp = await fetch(API_URL, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(body)
         });
+
         const data = await resp.json();
         const reply = data.choices?.[0]?.message?.content || "(no reply)";
         addMessage("assistant", reply);
         history.push({ role: "assistant", content: reply });
 		await saveSession();
-          } catch (err2) {
-            addMessage("system", "Error: " + err2.message);
+      } catch (err) {
+        addMessage("system", "Error: " + err.message);
       }
-          return;
-        }
-        // Partial content arrived before the error — keep what we streamed.
-      }
-
-      finalizeAssistantBubble(div, full || "(no reply)");
-      history.push({ role: "assistant", content: full || "(no reply)" });
-      await saveSession();
-
-      // If she opened a session this turn, the server auto-flips to Cash mode —
-      // reflect that here so the badge/HUD follow without a manual switch.
-      if (document.getElementById("mode").value !== "poker_cash") {
-        loadModeFor(currentSession);
-      }
-    }
-
-    function createAssistantBubble() {
-      const messagesEl = document.getElementById("messages");
-      const div = document.createElement("div");
-      div.className = "msg assistant streaming";
-      messagesEl.appendChild(div);
-      messagesEl.scrollTop = messagesEl.scrollHeight;  // instant — no smooth chasing
-      return div;
-    }
-
-    // Coalesce token updates to one render per animation frame (avoids re-parsing
-    // the whole message on every token, and the iOS ghosting from rapid repaints).
-    function updateAssistantBubble(div, text) {
-      div._pending = text;
-      if (div._raf) return;
-      div._raf = requestAnimationFrame(() => {
-        div._raf = 0;
-        const messagesEl = document.getElementById("messages");
-        const stick = messagesEl.scrollHeight - messagesEl.scrollTop - messagesEl.clientHeight < 90;
-        div.innerHTML = renderMarkdown(div._pending);
-        div.dataset.raw = div._pending;
-        if (stick) messagesEl.scrollTop = messagesEl.scrollHeight;  // follow only if near bottom
-      });
-    }
-
-    function finalizeAssistantBubble(div, text) {
-      if (div._raf) { cancelAnimationFrame(div._raf); div._raf = 0; }  // drop any queued render
-      div.classList.remove("streaming");
-      div.innerHTML = renderMarkdown(text);
-      div.dataset.raw = text;
-      addRateBar(div);
-      const messagesEl = document.getElementById("messages");
-      requestAnimationFrame(() => messagesEl.scrollTo({ top: messagesEl.scrollHeight, behavior: "smooth" }));
     }
 
 	function renderMarkdown(text) {
@@ -475,7 +364,6 @@
 	  up.addEventListener("click", () => rateMessage(div, 1, up, down));
 	  down.addEventListener("click", () => rateMessage(div, -1, up, down));
 	  bar.appendChild(up); bar.appendChild(down);
-	  bar.appendChild(makeCopyBtn(() => div.dataset.raw || div.textContent || ""));
 	  div.appendChild(bar);
 	}
 
@@ -494,80 +382,6 @@
 	  down.classList.toggle("rated", value === -1);
 	}
 
-	// Copy text to the clipboard. Uses the async Clipboard API when available
-	// (HTTPS / localhost), and falls back to a hidden-textarea + execCommand for
-	// iOS over plain-HTTP LAN (where navigator.clipboard is undefined).
-	function copyToClipboard(text) {
-	  text = text == null ? "" : String(text);
-	  // Only trust the async Clipboard API in a secure context; on the LAN PWA
-	  // (plain HTTP) it's either absent or resolves without actually copying, so
-	  // we go straight to the iOS-tuned execCommand path there.
-	  if (window.isSecureContext && navigator.clipboard && navigator.clipboard.writeText) {
-	    return navigator.clipboard.writeText(text).catch(() => legacyCopy(text));
-	  }
-	  return legacyCopy(text);
-	}
-	function legacyCopy(text) {
-	  return new Promise((resolve, reject) => {
-	    const ta = document.createElement("textarea");
-	    ta.value = text;
-	    // iOS will only copy from a readOnly + contentEditable field with a real
-	    // Range selection; readOnly also stops the keyboard from popping.
-	    ta.readOnly = true;
-	    ta.contentEditable = "true";
-	    ta.style.position = "fixed";
-	    ta.style.top = "0";
-	    ta.style.left = "0";
-	    ta.style.width = "1px";
-	    ta.style.height = "1px";
-	    ta.style.fontSize = "16px";  // avoid iOS zoom side-effects
-	    document.body.appendChild(ta);
-	    ta.focus();
-	    const range = document.createRange();
-	    range.selectNodeContents(ta);
-	    const sel = window.getSelection();
-	    sel.removeAllRanges();
-	    sel.addRange(range);
-	    ta.setSelectionRange(0, text.length);  // the bit iOS actually needs
-	    let ok = false;
-	    try { ok = document.execCommand("copy"); } catch (e) { ok = false; }
-	    sel.removeAllRanges();
-	    document.body.removeChild(ta);
-	    ok ? resolve() : reject(new Error("copy failed"));
-	  });
-	}
-	// A small per-message copy button. getText is read at click time.
-	function makeCopyBtn(getText) {
-	  const b = document.createElement("button");
-	  b.className = "copy-btn";
-	  b.type = "button";
-	  b.textContent = "⧉";
-	  b.title = "Copy message";
-	  b.addEventListener("click", (e) => {
-	    e.stopPropagation();
-	    const text = typeof getText === "function" ? getText() : getText;
-	    copyToClipboard(text)
-	      .then(() => {
-	        b.textContent = "✓"; b.classList.add("copied");
-	        setTimeout(() => { b.textContent = "⧉"; b.classList.remove("copied"); }, 1200);
-	      })
-	      .catch(() => {
-	        // Last resort (some iOS configs block programmatic copy): surface the
-	        // text in a prompt so it can be selected + copied by hand.
-	        window.prompt("Copy this message:", text);
-	        b.textContent = "⧉";
-	      });
-	  });
-	  return b;
-	}
-
-	// Grow the input textarea to fit its content (up to a cap, then it scrolls).
-	function autoGrow(el) {
-	  if (!el) return;
-	  el.style.height = "auto";
-	  el.style.height = Math.min(el.scrollHeight, 140) + "px";
-	}
-
 	function addMessage(role, text, autoScroll = true) {
 	  const messagesEl = document.getElementById("messages");
 
@@ -579,12 +393,6 @@
 	    addRateBar(msgDiv);
 	  } else {
 	    msgDiv.textContent = text;
-	    if (role === "user") {
-	      const bar = document.createElement("div");
-	      bar.className = "rate-bar";
-	      bar.appendChild(makeCopyBtn(() => text));
-	      msgDiv.appendChild(bar);
-	    }
 	  }
 	  messagesEl.appendChild(msgDiv);
 
@@ -598,102 +406,22 @@
 	}
 
 
-    // ----- Conversation mode (Talk / Cash) -----
-    const MODE_LABELS = { conversation: "💬 Talk", poker_cash: "♠ Cash" };
-
-    // Reflect a mode value across the controls + header accent (no network call).
-    function applyMode(value) {
-      if (!MODE_LABELS[value]) value = "conversation";
-      const desk = document.getElementById("mode");
-      const mob = document.getElementById("mobileMode");
-      const badge = document.getElementById("modeBadge");
-      if (desk) desk.value = value;
-      if (mob) mob.value = value;
-      if (badge) badge.textContent = MODE_LABELS[value];
-      document.body.classList.toggle("cash-mode", value === "poker_cash");
-      localStorage.setItem("lyraMode", value);
-    }
-
-    // User picked a mode: apply locally + persist it to this session on the server.
-    async function chooseMode(value) {
-      applyMode(value);
-      if (!currentSession) return;
-      try {
-        await fetch(`${RELAY_BASE}/sessions/${currentSession}/mode`, {
-          method: "POST", headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ mode: value })
-        });
-      } catch (e) { /* non-fatal: the mode still rides along in the chat body */ }
-    }
-
-    // Pull the active mode for a session from the server (fallback: last local choice).
-    async function loadModeFor(sessionId) {
-      let value = localStorage.getItem("lyraMode") || "conversation";
-      try {
-        const r = await fetch(`${RELAY_BASE}/sessions/${sessionId}/mode`);
-        if (r.ok) { const d = await r.json(); if (d.mode) value = d.mode; }
-      } catch (e) { /* keep the local fallback */ }
-      applyMode(value);
-    }
-
     async function checkHealth() {
       try {
         const resp = await fetch(API_URL.replace("/v1/chat/completions", "/_health"));
         if (resp.ok) {
           document.getElementById("status-dot").className = "dot ok";
           document.getElementById("status-text").textContent = "Relay Online";
-          document.getElementById("brandDot").className = "brand-dot ok";
         } else {
           throw new Error("Bad status");
         }
       } catch (err) {
         document.getElementById("status-dot").className = "dot fail";
         document.getElementById("status-text").textContent = "Relay Offline";
-        document.getElementById("brandDot").className = "brand-dot fail";
       }
     }
 
     document.addEventListener("DOMContentLoaded", () => {
-      // --- PWA: track the *visible* viewport height so the layout follows the
-      // iOS keyboard and the dynamic Safari toolbars (keeps the input bar visible
-      // instead of hiding behind the keyboard). Falls back to 100dvh via CSS.
-      function setAppHeight() {
-        const vv = window.visualViewport;
-        const h = (vv && vv.height) || window.innerHeight;
-        const off = (vv && vv.offsetTop) || 0;
-        const root = document.documentElement.style;
-        root.setProperty("--app-height", h + "px");
-        // iOS pans the visual viewport when the keyboard opens; follow its top
-        // edge so the pinned #chat sits exactly in the visible area.
-        root.setProperty("--app-offset", off + "px");
-        // Keyboard open ⇒ hide the bottom tab bar so the input pins to the keyboard.
-        document.body.classList.toggle("kb", (window.innerHeight - h) > 150);
-      }
-      // Re-measure across the keyboard animation: iOS reports a stale (too-short)
-      // height mid-animation, so sample a few times until it settles.
-      function nudgeAppHeight() {
-        setAppHeight();
-        [50, 150, 300, 550].forEach((t) => setTimeout(setAppHeight, t));
-      }
-      setAppHeight();
-      if (window.visualViewport) {
-        window.visualViewport.addEventListener("resize", nudgeAppHeight);
-        window.visualViewport.addEventListener("scroll", setAppHeight);
-      }
-      window.addEventListener("resize", nudgeAppHeight);
-      window.addEventListener("orientationchange", nudgeAppHeight);
-
-      // Keep the latest message in view when the keyboard opens/closes.
-      const userInputEl = document.getElementById("userInput");
-      userInputEl.addEventListener("focus", () => {
-        nudgeAppHeight();
-        setTimeout(() => {
-          const m = document.getElementById("messages");
-          m.scrollTo({ top: m.scrollHeight, behavior: "smooth" });
-        }, 350);
-      });
-      userInputEl.addEventListener("blur", nudgeAppHeight);
-
       // Mobile Menu Toggle
       const hamburgerMenu = document.getElementById("hamburgerMenu");
       const mobileMenu = document.getElementById("mobileMenu");
@@ -713,22 +441,20 @@
 
       hamburgerMenu.addEventListener("click", toggleMobileMenu);
       mobileMenuOverlay.addEventListener("click", closeMobileMenu);
-      document.getElementById("moreTab").addEventListener("click", toggleMobileMenu);
 
-      // Mode controls (Talk / Cash): the desktop select, the mobile-menu select,
-      // and the always-visible header badge all funnel through chooseMode.
+      // Sync mobile menu controls with desktop
       const mobileMode = document.getElementById("mobileMode");
       const desktopMode = document.getElementById("mode");
-      const modeBadge = document.getElementById("modeBadge");
 
-      desktopMode.addEventListener("change", (e) => chooseMode(e.target.value));
-      mobileMode.addEventListener("change", (e) => { closeMobileMenu(); chooseMode(e.target.value); });
-      modeBadge.addEventListener("click", () =>
-        chooseMode(desktopMode.value === "poker_cash" ? "conversation" : "poker_cash"));
+      // Sync mode selection
+      mobileMode.addEventListener("change", (e) => {
+        desktopMode.value = e.target.value;
+        desktopMode.dispatchEvent(new Event("change"));
+      });
 
-      // Reflect the last-used mode immediately; the per-session value loads once
-      // the current session is known (below).
-      applyMode(localStorage.getItem("lyraMode") || "conversation");
+      desktopMode.addEventListener("change", (e) => {
+        mobileMode.value = e.target.value;
+      });
 
       // Mobile theme toggle
       document.getElementById("mobileToggleThemeBtn").addEventListener("click", () => {
@@ -838,7 +564,6 @@
 		// Load current session history
 		if (currentSession) {
 		  await loadSession(currentSession);
-		  await loadModeFor(currentSession);
 		}
 	  })();
 
@@ -849,7 +574,6 @@
 	  localStorage.setItem("currentSession", currentSession);
 	  addMessage("system", `Switched to session: ${getSessionName(currentSession)}`);
 	  await loadSession(currentSession);
-	  await loadModeFor(currentSession);
 	});
 
 	// Create new session
@@ -1024,15 +748,11 @@
       checkHealth();
       setInterval(checkHealth, 10000);
 
-      // Input events. Enter inserts a newline and grows the box (like the Claude
-      // app) — you tap the arrow to send. ⌘/Ctrl+Enter sends from the keyboard.
+      // Input events
       document.getElementById("sendBtn").addEventListener("click", sendMessage);
-      const inputBox = document.getElementById("userInput");
-      inputBox.addEventListener("input", () => autoGrow(inputBox));
-      inputBox.addEventListener("keydown", e => {
-        if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) { e.preventDefault(); sendMessage(); }
+      document.getElementById("userInput").addEventListener("keypress", e => {
+        if (e.key === "Enter") sendMessage();
       });
-      autoGrow(inputBox);
 
       // ========== THINKING STREAM INTEGRATION ==========
       const thinkingPanel = document.getElementById("thinkingPanel");
@@ -1164,14 +884,14 @@
       document.getElementById("mobileFullLogBtn").addEventListener("click", () => {
         closeMobileMenu(); window.location.href = "/logs";
       });
+      document.getElementById("mobileMindBtn").addEventListener("click", () => {
+        closeMobileMenu(); window.location.href = "/self";
+      });
       document.getElementById("mobileJournalBtn").addEventListener("click", () => {
         closeMobileMenu(); window.location.href = "/journal";
       });
-      document.getElementById("mobileSessionBtn").addEventListener("click", () => {
-        closeMobileMenu(); window.location.href = "/session";
-      });
-      document.getElementById("mobileHistoryBtn").addEventListener("click", () => {
-        closeMobileMenu(); window.location.href = "/history";
+      document.getElementById("mobileHandsBtn").addEventListener("click", () => {
+        closeMobileMenu(); window.location.href = "/hands";
       });
 
       // Connect to the global live log on page load.

lyra/web/static/manifest.json

@@ -1,33 +1,20 @@
 {
-  "name": "Lyra",
+  "name": "Lyra Chat",
   "short_name": "Lyra",
-  "description": "Lyra — chat, mind, journal, and poker copilot.",
   "start_url": "./index.html",
-  "scope": "./",
   "display": "standalone",
-  "display_override": ["standalone", "minimal-ui"],
-  "orientation": "portrait",
-  "background_color": "#070707",
-  "theme_color": "#070707",
-  "categories": ["productivity", "utilities"],
+  "background_color": "#181818",
+  "theme_color": "#181818",
   "icons": [
     {
       "src": "icon-192.png",
       "sizes": "192x192",
-      "type": "image/png",
-      "purpose": "any"
+      "type": "image/png"
     },
     {
       "src": "icon-512.png",
       "sizes": "512x512",
-      "type": "image/png",
-      "purpose": "any"
-    },
-    {
-      "src": "icon-maskable-512.png",
-      "sizes": "512x512",
-      "type": "image/png",
-      "purpose": "maskable"
+      "type": "image/png"
     }
   ]
 }

lyra/web/static/session.html

@@ -1,275 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
-  <meta name="theme-color" content="#070707" />
-  <title>Lyra — Session</title>
-  <style>
-    :root {
-      --bg: #070707; --bg-elev: #0e0e0e; --bg-line: #141414; --border: #2a1d12;
-      --text: #e8e8e8; --fade: #8a8a8a; --accent: #ff7a00;
-      --good: #8fd694; --mid: #ffb347; --low: #ff6b6b;
-    }
-    * { box-sizing: border-box; }
-    html, body {
-      margin: 0; min-height: 100%; background: var(--bg); color: var(--text);
-      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-      -webkit-text-size-adjust: 100%;
-    }
-    header {
-      position: sticky; top: 0; z-index: 10; background: var(--bg-elev);
-      border-bottom: 1px solid var(--border); padding: env(safe-area-inset-top) 14px 0;
-    }
-    .topbar { display: flex; align-items: center; gap: 10px; padding: 13px 0 12px; }
-    .topbar h1 { font-size: 1.05rem; margin: 0; font-weight: 600; }
-    .topbar a.back { color: var(--accent); text-decoration: none; font-size: .95rem; }
-    .updated { margin-left: auto; color: var(--fade); font-size: .78rem; }
-    .dot { width: 9px; height: 9px; border-radius: 50%; background: var(--good); box-shadow: 0 0 8px var(--good); flex: none; opacity: .35; transition: opacity .2s; }
-    .dot.pulse { opacity: 1; }
-
-    main { max-width: 680px; margin: 0 auto; padding: 16px 14px 40px; }
-    .card { background: var(--bg-elev); border: 1px solid var(--border); border-radius: 14px; padding: 16px; margin-bottom: 14px; }
-    .label { color: var(--fade); font-size: .72rem; text-transform: uppercase; letter-spacing: .6px; margin: 0 0 10px; }
-
-    /* Header card */
-    .sess-top { display: flex; align-items: baseline; gap: 10px; flex-wrap: wrap; }
-    .sess-title { font-size: 1.25rem; font-weight: 700; }
-    .sess-sub { color: var(--fade); font-size: .9rem; }
-    .chips { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 10px; }
-    .chip { font-size: .8rem; color: var(--fade); background: var(--bg-line); border: 1px solid var(--border); border-radius: 999px; padding: 3px 10px; }
-    .chip b { color: var(--text); font-weight: 600; }
-
-    /* Stack card */
-    .stack-row { display: flex; align-items: flex-end; gap: 16px; flex-wrap: wrap; }
-    .stack-now { font-size: 2.3rem; font-weight: 800; letter-spacing: .2px; font-variant-numeric: tabular-nums; }
-    .net { font-size: 1.2rem; font-weight: 700; font-variant-numeric: tabular-nums; }
-    .net.up { color: var(--good); } .net.down { color: var(--low); } .net.flat { color: var(--fade); }
-    .stack-meta { color: var(--fade); font-size: .85rem; margin-left: auto; text-align: right; }
-    svg.spark { display: block; width: 100%; height: 56px; margin-top: 14px; }
-
-    /* Hands */
-    ul.rows { list-style: none; margin: 0; padding: 0; }
-    ul.rows li { padding: 10px 0; border-bottom: 1px solid var(--bg-line); font-size: .95rem; line-height: 1.45; }
-    ul.rows li:last-child { border-bottom: none; }
-    a.hand { color: var(--text); text-decoration: none; display: flex; gap: 8px; align-items: baseline; }
-    a.hand:hover { color: var(--accent); }
-    .pos { color: var(--accent); font-weight: 700; min-width: 38px; }
-    .cards { font-variant-numeric: tabular-nums; }
-    .res { margin-left: auto; font-variant-numeric: tabular-nums; }
-    .res.up { color: var(--good); } .res.down { color: var(--low); }
-    .tag { font-size: .7rem; color: var(--mid); border: 1px solid var(--border); border-radius: 999px; padding: 1px 7px; }
-    .villain b { color: var(--text); } .villain .cat { color: var(--mid); font-size: .78rem; }
-    .note-meta { color: var(--fade); font-size: .72rem; }
-
-    /* Rituals */
-    .gator {
-      display: flex; align-items: center; gap: 12px; background: #1a2e10;
-      border: 1px solid #3c6b1e; border-radius: 14px; padding: 14px 16px; margin-bottom: 14px;
-    }
-    .gator .ico { font-size: 1.7rem; }
-    .gator b { color: #b6e88a; } .gator .sub { color: #8fbf6a; font-size: .82rem; }
-    .scar-cls {
-      font-size: .68rem; text-transform: uppercase; letter-spacing: .4px; border-radius: 999px;
-      padding: 1px 7px; border: 1px solid var(--border); margin-left: 6px;
-    }
-    .scar-cls.punt { color: var(--low); border-color: var(--low); }
-    .scar-cls.cooler { color: var(--mid); border-color: var(--mid); }
-    .scar-cls.standard { color: var(--fade); }
-    .card.scar { border-color: #4a2222; } .card.scar .label { color: #d98a8a; }
-    .card.conf { border-color: #234a23; } .card.conf .label { color: var(--good); }
-    .empty { color: var(--fade); font-size: .92rem; }
-    .err { color: var(--low); text-align: center; padding: 30px; }
-    .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; }
-  </style>
-</head>
-<body>
-  <header>
-    <div class="topbar">
-      <span class="dot" id="dot"></span>
-      <h1>🎬 Session</h1>
-      <a class="back" href="/">← Chat</a>
-      <a class="back" href="/history" title="Past sessions">📚 Sessions</a>
-      <a class="back" href="/hands" title="All recorded hands">🃏 Hands</a>
-      <span class="updated" id="updated">—</span>
-    </div>
-  </header>
-  <main id="root"><p class="err" id="boot">Loading the table…</p></main>
-
-  <script>
-    const root = document.getElementById('root');
-    const dot = document.getElementById('dot');
-    const updatedEl = document.getElementById('updated');
-
-    function esc(s){ const d=document.createElement('div'); d.textContent = s==null?'':String(s); return d.innerHTML; }
-    function money(v){ if (v == null) return '—'; const n = Number(v); return (n<0?'-$':'$') + Math.abs(n).toLocaleString(); }
-    function signed(v){ if (v == null) return '—'; const n = Number(v); return (n>0?'+$':n<0?'-$':'$') + Math.abs(n).toLocaleString(); }
-
-    function ago(iso){
-      if(!iso) return '—';
-      const s = Math.max(0, (Date.now() - new Date(iso).getTime())/1000);
-      if(s < 60) return 'just now';
-      if(s < 3600) return Math.round(s/60)+'m ago';
-      if(s < 86400) return Math.round(s/3600)+'h ago';
-      return Math.round(s/86400)+'d ago';
-    }
-    function elapsed(iso){
-      if(!iso) return '—';
-      const s = Math.max(0, (Date.now() - new Date(iso).getTime())/1000);
-      const h = Math.floor(s/3600), m = Math.round((s%3600)/60);
-      return h ? `${h}h ${m}m` : `${m}m`;
-    }
-
-    // Tiny inline sparkline of the stack-over-time series.
-    function sparkline(series){
-      const pts = series.map(p => Number(p.amount)).filter(n => !isNaN(n));
-      if (pts.length < 2) return '';
-      const W = 600, H = 56, pad = 4;
-      const min = Math.min(...pts), max = Math.max(...pts), span = (max - min) || 1;
-      const x = i => pad + (i / (pts.length - 1)) * (W - 2*pad);
-      const y = v => H - pad - ((v - min) / span) * (H - 2*pad);
-      const d = pts.map((v,i) => `${x(i).toFixed(1)},${y(v).toFixed(1)}`).join(' ');
-      const last = pts[pts.length-1], first = pts[0];
-      const col = last >= first ? 'var(--good)' : 'var(--low)';
-      return `<svg class="spark" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none">
-        <polyline points="${d}" fill="none" stroke="${col}" stroke-width="2"
-          stroke-linejoin="round" stroke-linecap="round" />
-        <circle cx="${x(pts.length-1).toFixed(1)}" cy="${y(last).toFixed(1)}" r="3" fill="${col}" />
-      </svg>`;
-    }
-
-    function netClass(v){ return v == null ? 'flat' : v > 0 ? 'up' : v < 0 ? 'down' : 'flat'; }
-
-    function render(data){
-      const s = data.session;
-      if (!s) {
-        root.innerHTML = `<div class="big-empty">
-          <div class="ico">🪑</div>
-          <p>No live session right now.<br>Start one from <a href="/">chat</a> — switch to ♠ Cash and tell Lyra you're sitting down.</p>
-        </div>`;
-        updatedEl.textContent = '';
-        return;
-      }
-      const stack = data.stack || {};
-      const hands = data.hands || [];
-      const villains = data.villains || [];
-      const notes = data.notes || [];
-      const stats = data.stats || {};
-      const rituals = data.rituals || {};
-      const scars = rituals.scars || [];
-      const confidence = rituals.confidence || [];
-      const resets = rituals.resets || [];
-
-      const title = [s.stakes, s.game].filter(Boolean).join(' ') || 'Session';
-      const tagBits = Object.entries(stats.tags || {}).map(([k,v]) => `${k}×${v}`).join(' · ');
-
-      root.innerHTML = `
-        ${rituals.alligator ? `<div class="gator">
-          <span class="ico">🐊</span>
-          <div><b>Alligator Blood</b><div class="sub">refuse to die · no forced miracles · make them beat you correctly</div></div>
-        </div>` : ''}
-
-        <div class="card">
-          <div class="sess-top">
-            <span class="sess-title">${esc(title)}</span>
-            <span class="sess-sub">${esc(s.venue || 'unknown room')}${s.status && s.status!=='live' ? ' · '+esc(s.status) : ''}</span>
-          </div>
-          <div class="chips">
-            <span class="chip">⏱ <b>${elapsed(s.started_at)}</b></span>
-            <span class="chip">in <b>${money(s.buy_in_total)}</b></span>
-            <span class="chip">${esc(s.format || 'cash')}</span>
-            <span class="chip"><b>${hands.length}</b> hands</span>
-            ${resets.length ? `<span class="chip">🔄 <b>${resets.length}</b> reset${resets.length>1?'s':''}</span>` : ''}
-          </div>
-        </div>
-
-        <div class="card">
-          <p class="label">Stack</p>
-          <div class="stack-row">
-            <span class="stack-now">${stack.current == null ? '—' : money(stack.current)}</span>
-            <span class="net ${netClass(stack.net)}">${stack.net == null ? '' : signed(stack.net)}</span>
-            <span class="stack-meta">bought in ${money(stack.buy_in)}<br>${(stack.log||[]).length} update(s)</span>
-          </div>
-          ${sparkline(stack.log || [])}
-          ${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">Hands this session</p>
-          ${hands.length ? `<ul class="rows">${hands.slice().reverse().map(h => `
-            <li><a class="hand" href="/hand/${h.id}">
-              <span class="pos">${esc(h.position || '?')}</span>
-              <span class="cards">${esc(h.hole_cards || '')}${h.board ? ' · '+esc(h.board) : ''}</span>
-              ${h.tag ? `<span class="tag">${esc(h.tag)}</span>` : ''}
-              ${h.result != null ? `<span class="res ${h.result>=0?'up':'down'}">${signed(h.result)}</span>` : ''}
-            </a></li>`).join('')}</ul>`
-            : '<p class="empty">No hands logged yet.</p>'}
-        </div>
-
-        <div class="card conf">
-          <p class="label">💰 Confidence Bank</p>
-          ${confidence.length ? `<ul class="rows">${confidence.slice().reverse().map(c => `
-            <li>${esc(c.content)}${c.hand_id ? ` · <a class="hand" style="display:inline" href="/hand/${c.hand_id}">hand</a>` : ''}
-              <div class="note-meta">${ago(c.at)}</div></li>`).join('')}</ul>`
-            : '<p class="empty">Nothing banked yet — disciplined plays land here.</p>'}
-        </div>
-
-        <div class="card scar">
-          <p class="label">🩹 Scar Notes</p>
-          ${scars.length ? `<ul class="rows">${scars.slice().reverse().map(sc => `
-            <li>${esc(sc.content)}${sc.classification ? `<span class="scar-cls ${esc(sc.classification)}">${esc(sc.classification)}</span>` : ''}
-              ${sc.hand_id ? ` · <a class="hand" style="display:inline" href="/hand/${sc.hand_id}">hand</a>` : ''}
-              <div class="note-meta">${ago(sc.at)}</div></li>`).join('')}</ul>`
-            : '<p class="empty">No scars logged — mistakes to study land here.</p>'}
-        </div>
-
-        <div class="card">
-          <p class="label">Villains seen</p>
-          ${villains.length ? `<ul class="rows">${villains.map(v => `
-            <li class="villain">
-              <b>${esc(v.name)}</b> ${v.category ? `<span class="cat">[${esc(v.category)}]</span>` : ''}
-              ${v.tendencies ? `<div>${esc(v.tendencies)}</div>` : ''}
-              ${v.last_note ? `<div class="note-meta">“${esc(v.last_note)}”</div>` : ''}
-            </li>`).join('')}</ul>`
-            : '<p class="empty">No reads logged this session.</p>'}
-        </div>
-
-        <div class="card">
-          <p class="label">Her notes</p>
-          ${notes.length ? `<ul class="rows">${notes.map(n => `
-            <li>${esc(n.content)}<div class="note-meta">${esc(n.kind)} · ${ago(n.created_at)}</div></li>`).join('')}</ul>`
-            : '<p class="empty">Nothing jotted this session.</p>'}
-        </div>
-
-        <div class="card">
-          <p class="label">Session stats</p>
-          <div class="chips">
-            <span class="chip">logged <b>${stats.hands_logged ?? 0}</b></span>
-            ${tagBits ? `<span class="chip">${esc(tagBits)}</span>` : ''}
-            ${stats.context_per_hour != null ? `<span class="chip">${esc(title)} lifetime <b>${signed(stats.context_per_hour)}/hr</b></span>` : ''}
-          </div>
-        </div>
-      `;
-      updatedEl.textContent = 'updated ' + ago(data._fetched);
-    }
-
-    async function refresh(){
-      try {
-        const r = await fetch('/session/data', { cache: 'no-store' });
-        const data = await r.json();
-        data._fetched = new Date().toISOString();
-        dot.classList.add('pulse'); setTimeout(() => dot.classList.remove('pulse'), 400);
-        render(data);
-      } catch (e) {
-        if (!root.querySelector('.card')) root.innerHTML = '<p class="err">Couldn\'t reach the table. Is the server up?</p>';
-      }
-    }
-
-    refresh();
-    setInterval(refresh, 5000);
-    document.addEventListener('visibilitychange', () => { if (!document.hidden) refresh(); });
-  </script>
-</body>
-</html>

lyra/web/static/style.css

@@ -1,61 +1,31 @@
 :root {
   --bg-dark: #070707;
-  --bg-elev: #0e0e0e;
-  --bg-line: #141414;
-  --bg-panel: #0e0e0e;
-  --border: #2a1d12;
-  --border-bright: #4a2f15;
+  --bg-panel: rgba(255, 122, 0, 0.1);
   --accent: #ff7a00;
-  --gold: #ffb347;
-  --good: #8fd694;
-  --bad: #ff5a5a;
-  --accent-soft: rgba(255, 122, 0, 0.10);
-  --accent-glow: 0 0 6px rgba(255, 122, 0, 0.18);
+  --accent-glow: 0 0 6px rgba(255,122,0,0.28);
   --text-main: #e8e8e8;
-  --text-fade: #8a8a8a;
-  --font-console: "IBM Plex Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
-  --font-voice: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  --text-fade: #999;
+  --font-console: "IBM Plex Mono", monospace;
 }
 
-/* Light mode (secondary — Brian runs dark) */
+/* Light mode variables */
 body {
-  --bg-dark: #f5f3ef;
-  --bg-elev: #ffffff;
-  --bg-line: #ece8e1;
-  --bg-panel: #ffffff;
-  --border: #e2dacb;
-  --border-bright: #c9a87a;
-  --accent: #c75e00;
-  --gold: #b8791f;
-  --good: #3f9a52;
-  --bad: #c0392b;
-  --accent-soft: rgba(199, 94, 0, 0.08);
-  --accent-glow: none;
+  --bg-dark: #f5f5f5;
+  --bg-panel: rgba(255, 122, 0, 0.05);
+  --accent: #ff7a00;
+  --accent-glow: 0 0 6px rgba(255,122,0,0.28);
   --text-main: #1a1a1a;
-  --text-fade: #6a6a6a;
-  --text: var(--text-main);   /* alias: some rules reference var(--text) */
+  --text-fade: #666;
 }
 
-/* Dark mode (primary — RTO warm low-glow) */
+/* Dark mode variables */
 body.dark {
   --bg-dark: #070707;
-  --bg-elev: #0e0e0e;
-  --bg-line: #141414;
-  --bg-panel: #0e0e0e;
-  --border: #2a1d12;
-  --border-bright: #4a2f15;
+  --bg-panel: rgba(255, 122, 0, 0.1);
   --accent: #ff7a00;
-  --gold: #ffb347;
-  --good: #8fd694;
-  --bad: #ff5a5a;
-  --accent-soft: rgba(255, 122, 0, 0.10);
-  --accent-glow: 0 0 6px rgba(255, 122, 0, 0.18);
+  --accent-glow: 0 0 6px rgba(255,122,0,0.28);
   --text-main: #e8e8e8;
-  --text-fade: #8a8a8a;
-}
-
-html {
-  overscroll-behavior: none;
+  --text-fade: #999;
 }
 
 body {
@@ -63,13 +33,10 @@ body {
   background: var(--bg-dark);
   color: var(--text-main);
   font-family: var(--font-console);
-  height: 100vh;        /* fallback for old browsers */
-  height: 100dvh;
+  height: 100vh;
   display: flex;
   justify-content: center;
   align-items: center;
-  overscroll-behavior: none;
-  -webkit-tap-highlight-color: transparent;
 }
 
 #chat {
@@ -78,9 +45,9 @@ body {
   height: 95vh;
   display: flex;
   flex-direction: column;
-  border: 1px solid var(--border);
-  border-radius: 12px;
-  box-shadow: none;
+  border: 1px solid var(--accent);
+  border-radius: 10px;
+  box-shadow: var(--accent-glow);
   background: var(--bg-dark);
   overflow: hidden;
 }
@@ -91,176 +58,109 @@ body {
   align-items: center;
   gap: 8px;
   padding: 8px 12px;
-  border-bottom: 1px solid var(--border);
-  background-color: var(--bg-elev);
+  border-bottom: 1px solid var(--accent);
+  background-color: rgba(255, 122, 0, 0.05);
 }
 #status {
   justify-content: flex-start;
-  border-top: 1px solid var(--border);
+  border-top: 1px solid var(--accent);
 }
 
-/* Mode badge: the always-visible Talk/Cash toggle. Hidden on desktop (the header
-   <select> handles it there); shown in the minimal mobile header (see media query). */
-.mode-badge {
-  display: none;
-  align-items: center;
-  gap: 4px;
-  font-family: var(--font-console);
-  font-size: 0.82rem;
-  color: var(--text-fade);
-  background: var(--bg-line);
-  border: 1px solid var(--border);
-  border-radius: 999px;
-  padding: 4px 11px;
-  -webkit-tap-highlight-color: transparent;
-}
-/* Cash mode: light up the badge (and the chat brand) so the table state is obvious. */
-body.cash-mode .mode-badge {
-  color: var(--accent);
-  border-color: var(--accent);
-  background: var(--accent-soft);
-}
-body.cash-mode .brand { color: var(--accent); }
-
 label, select, button {
   font-family: var(--font-console);
   font-size: 0.9rem;
   color: var(--text-main);
-  background: var(--bg-line);
-  border: 1px solid var(--border);
-  border-radius: 6px;
-  padding: 5px 9px;
-  transition: border-color .15s, background-color .15s;
+  background: transparent;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 4px 8px;
 }
-label { background: transparent; border-color: transparent; padding-left: 0; }
 
 button:hover, select:hover {
-  border-color: var(--border-bright);
-  background: var(--accent-soft);
+  box-shadow: 0 0 8px var(--accent);
   cursor: pointer;
 }
 
 #thinkingStreamBtn {
-  background: var(--bg-line);
-  border-color: var(--border-bright);
-  color: var(--gold);
+  background: rgba(255, 179, 71, 0.2);
+  border-color: #ffb347;
 }
 
 #thinkingStreamBtn:hover {
-  background: var(--accent-soft);
-  border-color: var(--gold);
+  box-shadow: 0 0 8px #ffb347;
+  background: rgba(255, 179, 71, 0.3);
 }
 
 /* Chat area */
 #messages {
   flex: 1;
-  min-height: 0;
   padding: 16px;
   overflow-y: auto;
-  overscroll-behavior: contain;
-  -webkit-overflow-scrolling: touch;
   display: flex;
   flex-direction: column;
   gap: 8px;
-  /* No CSS smooth-scroll: during streaming, per-token smooth scrolls pile up and
-     iOS Safari leaves ghost paint frames. Smooth is applied explicitly in JS where
-     it's a one-shot (load/finalize). */
+  scroll-behavior: smooth;
 }
 
 /* Messages */
 .msg {
   max-width: 80%;
   padding: 10px 14px;
-  border-radius: 12px;
+  border-radius: 8px;
   line-height: 1.4;
   word-wrap: break-word;
-  box-shadow: none;
+  box-shadow: 0 0 8px rgba(255,122,0,0.2);
 }
 .msg.user {
   align-self: flex-end;
-  background: var(--accent-soft);
-  border: 1px solid var(--border-bright);
-  border-bottom-right-radius: 4px;
+  background: rgba(255,122,0,0.15);
+  border: 1px solid var(--accent);
 }
 .msg.assistant {
   align-self: flex-start;
-  background: var(--bg-elev);
-  border: 1px solid var(--border);
-  border-bottom-left-radius: 4px;
+  background: rgba(255,122,0,0.08);
+  border: 1px solid rgba(255,122,0,0.5);
 }
 .msg.system {
   align-self: center;
-  font-size: 0.78rem;
+  font-size: 0.8rem;
   color: var(--text-fade);
-  text-align: center;
-  padding: 4px 10px;
 }
 
 /* Input bar */
 #input {
   display: flex;
-  align-items: flex-end;   /* arrow stays at the bottom as the textarea grows */
-  border-top: 1px solid var(--border);
-  background: var(--bg-elev);
+  border-top: 1px solid var(--accent);
+  background: rgba(255, 122, 0, 0.05);
   padding: 10px;
 }
 #userInput {
   flex: 1;
-  background: var(--bg-line);
+  background: transparent;
   color: var(--text-main);
-  border: 1px solid var(--border);
-  border-radius: 16px;
-  padding: 9px 12px;
-  font-family: var(--font-console);
-  font-size: 0.95rem;
-  line-height: 1.4;
-  resize: none;             /* grown programmatically, not by the drag handle */
-  max-height: 140px;
-  overflow-y: auto;
-  transition: border-color .15s, box-shadow .15s;
-}
-#userInput::placeholder { color: var(--text-fade); }
-#userInput:focus {
-  outline: none;
-  border-color: var(--accent);
-  box-shadow: var(--accent-glow);
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 8px;
 }
 #sendBtn {
   margin-left: 8px;
-  flex: none;
-  width: 38px;
-  height: 38px;
-  padding: 0;
-  border-radius: 50%;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 1.25rem;
-  line-height: 1;
-  background: var(--accent);
-  color: #0a0a0a;
-  border-color: var(--accent);
-  font-weight: 600;
 }
-#sendBtn:hover { background: var(--gold); border-color: var(--gold); }
-#sendBtn:disabled { opacity: .45; background: var(--bg-line); color: var(--text-fade); border-color: var(--border); }
 
 /* Relay status dot */
 #status {
   display: flex;
   align-items: center;
+  margin: 10px 0;
   gap: 8px;
-  font-family: var(--font-console);
-  font-size: 0.82rem;
-  color: var(--text-fade);
+  font-family: monospace;
+  color: #f5f5f5;
 }
 
 #status-dot {
-  width: 9px;
-  height: 9px;
+  width: 10px;
+  height: 10px;
   border-radius: 50%;
   display: inline-block;
-  background: var(--text-fade);
 }
 
 @keyframes pulseGreen {
@@ -270,29 +170,29 @@ button:hover, select:hover {
 }
 
 .dot.ok {
-  background: var(--good);
+  background: #8fd694;
   animation: pulseGreen 2s infinite ease-in-out;
 }
 
 /* Offline state stays solid red */
 .dot.fail {
-  background: var(--bad);
-  box-shadow: 0 0 8px rgba(255, 90, 90, 0.5);
+  background: #ff3333;
+  box-shadow: 0 0 10px #ff3333;
 }
 
 
 /* Dropdown (session selector) styling */
 select {
-  background-color: var(--bg-line);
+  background-color: var(--bg-dark);
   color: var(--text-main);
-  border: 1px solid var(--border);
+  border: 1px solid #b84a12;
   border-radius: 6px;
-  padding: 5px 8px;
+  padding: 4px 6px;
   font-size: 14px;
 }
 
 select option {
-  background-color: var(--bg-elev);
+  background-color: var(--bg-dark);
   color: var(--text-main);
 }
 
@@ -300,8 +200,8 @@ select option {
 select:focus,
 select:hover {
   outline: none;
-  border-color: var(--accent);
-  background-color: var(--bg-line);
+  border-color: #ff8a00;
+  background-color: var(--bg-panel);
 }
 
 /* Settings Modal */
@@ -335,10 +235,10 @@ select:hover {
   top: 50%;
   left: 50%;
   transform: translate(-50%, -50%);
-  background: var(--bg-elev);
-  border: 1px solid var(--border);
-  border-radius: 14px;
-  box-shadow: 0 24px 60px rgba(0, 0, 0, 0.6);
+  background: linear-gradient(180deg, rgba(255,122,0,0.1) 0%, rgba(10,10,10,0.95) 100%);
+  border: 2px solid var(--accent);
+  border-radius: 12px;
+  box-shadow: var(--accent-glow);
   min-width: 400px;
   max-width: 600px;
   max-height: 80vh;
@@ -351,8 +251,8 @@ select:hover {
   justify-content: space-between;
   align-items: center;
   padding: 16px 20px;
-  border-bottom: 1px solid var(--border);
-  background: var(--bg-line);
+  border-bottom: 1px solid var(--accent);
+  background: rgba(255,122,0,0.1);
 }
 
 .modal-header h3 {
@@ -377,8 +277,8 @@ select:hover {
 }
 
 .close-btn:hover {
-  background: var(--accent-soft);
-  color: var(--accent);
+  background: rgba(255,122,0,0.2);
+  box-shadow: 0 0 8px var(--accent);
 }
 
 .modal-body {
@@ -407,16 +307,17 @@ select:hover {
   display: flex;
   flex-direction: column;
   padding: 12px;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--bg-line);
+  border: 1px solid rgba(255,122,0,0.3);
+  border-radius: 6px;
+  background: rgba(255,122,0,0.05);
   cursor: pointer;
-  transition: border-color 0.15s, background-color 0.15s;
+  transition: all 0.2s;
 }
 
 .radio-label:hover {
-  border-color: var(--border-bright);
-  background: var(--accent-soft);
+  border-color: var(--accent);
+  background: rgba(255,122,0,0.1);
+  box-shadow: 0 0 8px rgba(255,122,0,0.3);
 }
 
 .radio-label input[type="radio"] {
@@ -457,20 +358,19 @@ select:hover {
   justify-content: flex-end;
   gap: 10px;
   padding: 16px 20px;
-  border-top: 1px solid var(--border);
-  background: var(--bg-line);
+  border-top: 1px solid var(--accent);
+  background: rgba(255,122,0,0.05);
 }
 
 .primary-btn {
   background: var(--accent);
-  color: #0a0a0a;
-  font-weight: 600;
-  border-color: var(--accent);
+  color: #000;
+  font-weight: bold;
 }
 
 .primary-btn:hover {
-  background: var(--gold);
-  border-color: var(--gold);
+  background: #ff8a00;
+  box-shadow: var(--accent-glow);
 }
 
 /* Session List */
@@ -487,15 +387,15 @@ select:hover {
   justify-content: space-between;
   align-items: center;
   padding: 12px;
-  border: 1px solid var(--border);
-  border-radius: 8px;
-  background: var(--bg-line);
-  transition: border-color 0.15s, background-color 0.15s;
+  border: 1px solid rgba(255,122,0,0.3);
+  border-radius: 6px;
+  background: rgba(255,122,0,0.05);
+  transition: all 0.2s;
 }
 
 .session-item:hover {
-  border-color: var(--border-bright);
-  background: var(--accent-soft);
+  border-color: var(--accent);
+  background: rgba(255,122,0,0.1);
 }
 
 .session-info {
@@ -535,8 +435,8 @@ select:hover {
 
 /* Thinking Stream Panel */
 .thinking-panel {
-  border-top: 1px solid var(--border);
-  background: var(--bg-dark);
+  border-top: 1px solid var(--accent);
+  background: rgba(255, 122, 0, 0.02);
   display: flex;
   flex-direction: column;
   transition: max-height 0.3s ease;
@@ -552,16 +452,16 @@ select:hover {
   justify-content: space-between;
   align-items: center;
   padding: 10px 12px;
-  background: var(--bg-elev);
+  background: rgba(255, 122, 0, 0.08);
   cursor: pointer;
   user-select: none;
-  border-bottom: 1px solid var(--border);
+  border-bottom: 1px solid rgba(255, 122, 0, 0.2);
   font-size: 0.9rem;
   font-weight: 500;
 }
 
 .thinking-header:hover {
-  background: var(--accent-soft);
+  background: rgba(255, 122, 0, 0.12);
 }
 
 .thinking-controls {
@@ -589,19 +489,19 @@ select:hover {
 
 .thinking-clear-btn,
 .thinking-toggle-btn {
-  background: var(--bg-line);
-  border: 1px solid var(--border);
+  background: transparent;
+  border: 1px solid rgba(255, 122, 0, 0.5);
   color: var(--text-main);
   padding: 4px 8px;
-  border-radius: 6px;
+  border-radius: 4px;
   cursor: pointer;
   font-size: 0.85rem;
 }
 
 .thinking-clear-btn:hover,
 .thinking-toggle-btn:hover {
-  background: var(--accent-soft);
-  border-color: var(--border-bright);
+  background: rgba(255, 122, 0, 0.2);
+  box-shadow: 0 0 6px rgba(255, 122, 0, 0.3);
 }
 
 .thinking-toggle-btn {
@@ -713,12 +613,6 @@ select:hover {
 
 /* ========== MOBILE RESPONSIVE STYLES ========== */
 
-/* Wordmark + status dot — shown only in the mobile header (media query below) */
-.brand, .brand-dot { display: none; }
-
-/* Bottom tab bar — mobile only (shown in the media query) */
-#tabbar { display: none; }
-
 /* Hamburger Menu */
 .hamburger-menu {
   display: none;
@@ -726,9 +620,9 @@ select:hover {
   gap: 4px;
   cursor: pointer;
   padding: 8px;
-  border: 1px solid var(--border-bright);
-  border-radius: 8px;
-  background: var(--bg-line);
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  background: transparent;
   z-index: 100;
 }
 
@@ -760,17 +654,13 @@ select:hover {
   left: -100%;
   width: 280px;
   height: 100vh;
-  height: 100dvh;
-  background: var(--bg-elev);
-  border-right: 1px solid var(--border);
-  box-shadow: 8px 0 32px rgba(0, 0, 0, 0.5);
+  background: var(--bg-dark);
+  border-right: 2px solid var(--accent);
+  box-shadow: var(--accent-glow);
   z-index: 999;
   transition: left 0.3s ease;
   overflow-y: auto;
-  overscroll-behavior: contain;
   padding: 20px;
-  padding-top: calc(20px + env(safe-area-inset-top));
-  padding-bottom: calc(20px + env(safe-area-inset-bottom));
   flex-direction: column;
   gap: 16px;
 }
@@ -799,7 +689,7 @@ select:hover {
   flex-direction: column;
   gap: 8px;
   padding-bottom: 16px;
-  border-bottom: 1px solid var(--border);
+  border-bottom: 1px solid rgba(255, 122, 0, 0.3);
 }
 
 .mobile-menu-section:last-child {
@@ -826,25 +716,15 @@ select:hover {
 @media screen and (max-width: 768px) {
   body {
     padding: 0;
-    background: var(--bg-elev);  /* matches the tab bar so any strip below #chat is seamless */
   }
 
   #chat {
-    position: fixed;
-    top: 0; left: 0; right: 0;
     width: 100%;
-    height: 100dvh;     /* the *visible* viewport (excludes the home-indicator zone);
-                           overrides the base 95vh. Body bg matches the bar below it. */
-    background: var(--bg-dark);
+    max-width: 100%;
+    height: 100vh;
     border-radius: 0;
-    border: none;
-  }
-  /* Only while the keyboard is open do we follow the *visible* viewport: release
-     the bottom anchor and size from the top by the measured visible height. */
-  body.kb #chat {
-    bottom: auto;
-    height: var(--app-height, 100dvh);
-    transform: translateY(var(--app-offset, 0px));
+    border-left: none;
+    border-right: none;
   }
 
   /* Show hamburger, hide desktop header controls */
@@ -854,39 +734,17 @@ select:hover {
 
   #model-select {
     padding: 12px;
-    padding-top: calc(12px + env(safe-area-inset-top));
-    padding-left: calc(14px + env(safe-area-inset-left));
-    padding-right: calc(14px + env(safe-area-inset-right));
-    justify-content: flex-start;
-    gap: 12px;
+    justify-content: space-between;
   }
 
-  /* Mobile header is [≡]  Lyra  [♠ Cash]  [●] — hide everything else. */
-  #model-select > *:not(.hamburger-menu):not(.brand):not(.brand-dot):not(.mode-badge) {
+  /* Hide all controls except hamburger on mobile */
+  #model-select > *:not(.hamburger-menu) {
     display: none;
   }
-  .mode-badge { display: inline-flex; margin-left: 4px; }
-  .brand {
-    display: block;
-    font-family: var(--font-console);
-    font-weight: 600;
-    font-size: 1.1rem;
-    color: var(--accent);
-    letter-spacing: 0.5px;
-  }
-  .brand-dot {
-    display: block;
-    width: 9px; height: 9px;
-    border-radius: 50%;
-    background: var(--text-fade);
-    margin-left: auto;
-    transition: background-color .2s;
-  }
-  .brand-dot.ok { background: var(--good); box-shadow: 0 0 8px rgba(143, 214, 148, .55); }
-  .brand-dot.fail { background: var(--bad); }
 
-  #session-select { display: none; }
-  #status { display: none; }   /* relay status now lives as the header dot */
+  #session-select {
+    display: none;
+  }
 
   /* Show mobile menu */
   .mobile-menu {
@@ -905,61 +763,19 @@ select:hover {
     font-size: 0.85rem;
   }
 
-  /* Input area - bigger touch targets. The tab bar owns the bottom safe-area
-     inset now (the input is no longer the bottom-most element). */
+  /* Input area - bigger touch targets */
   #input {
     padding: 12px;
-    padding-left: calc(12px + env(safe-area-inset-left));
-    padding-right: calc(12px + env(safe-area-inset-right));
   }
 
-  /* Bottom tab bar */
-  #tabbar {
-    display: flex;
-    flex: none;          /* never let it be compressed/clipped by the flex column */
-    border-top: 1px solid var(--border);
-    background: var(--bg-elev);
-    padding-bottom: 6px;  /* 100dvh already excludes the home-indicator zone */
-    padding-left: env(safe-area-inset-left);
-    padding-right: env(safe-area-inset-right);
-  }
-  #tabbar .tab {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    gap: 3px;
-    padding: 7px 0 5px;
-    background: none;
-    border: none;
-    border-radius: 0;
-    color: var(--text-fade);
-    font-family: var(--font-console);
-    text-decoration: none;
-    -webkit-tap-highlight-color: transparent;
-  }
-  #tabbar .tab:hover { background: none; }
-  #tabbar .tab:active { background: var(--accent-soft); }
-  #tabbar .tab .ti { font-size: 1.3rem; line-height: 1; filter: grayscale(.45); }
-  #tabbar .tab .tl { font-size: .64rem; letter-spacing: .3px; }
-  #tabbar .tab.active { color: var(--accent); }
-  #tabbar .tab.active .ti { filter: none; }
-  body.kb #tabbar { display: none; }   /* keyboard open ⇒ hide so input pins to keyboard */
-
-  /* The "More" tab is the menu trigger now — retire the hamburger. */
-  .hamburger-menu { display: none !important; }
-
   #userInput {
     font-size: 16px; /* Prevents zoom on iOS */
-    padding: 11px 14px;
+    padding: 12px;
   }
 
   #sendBtn {
-    width: 44px;     /* comfortable touch target */
-    height: 44px;
-    padding: 0;
-    font-size: 1.35rem;
+    padding: 12px 16px;
+    font-size: 1rem;
   }
 
   /* Modal - full width on mobile */
@@ -1058,14 +874,12 @@ select:hover {
 
   #userInput {
     font-size: 16px;
-    padding: 10px 13px;
+    padding: 10px;
   }
 
   #sendBtn {
-    width: 42px;
-    height: 42px;
-    padding: 0;
-    font-size: 1.3rem;
+    padding: 10px 14px;
+    font-size: 0.95rem;
   }
 
   .modal-header h3 {
@@ -1181,16 +995,6 @@ select:hover {
 }
 .msg.assistant pre code { background: none; padding: 0; font-size: 0.85em; }
 
-/* Streaming: a blinking caret while tokens arrive (and a min-size while empty). */
-.msg.assistant.streaming { min-width: 1.4em; min-height: 1.1em; }
-.msg.assistant.streaming::after {
-  content: "▋";
-  margin-left: 1px;
-  color: var(--accent);
-  animation: caretBlink 1s steps(1) infinite;
-}
-@keyframes caretBlink { 0%, 50% { opacity: 0.85; } 50.01%, 100% { opacity: 0; } }
-
 /* Behind-the-scenes 👍/👎 feedback (fine-tune signal) — subtle until hovered. */
 .rate-bar { display: flex; gap: 6px; margin-top: 7px; opacity: 0.3; transition: opacity .15s; }
 .msg.assistant:hover .rate-bar { opacity: 0.85; }
@@ -1199,31 +1003,5 @@ select:hover {
   padding: 2px 5px; border-radius: 5px; line-height: 1; filter: grayscale(0.6);
   -webkit-tap-highlight-color: transparent;
 }
-.rate-btn:hover { filter: none; background: var(--accent-soft); }
-.rate-btn.rated { filter: none; background: rgba(255,122,0,0.22); opacity: 1; }
-
-/* Per-message copy button (lives in the rate-bar for assistant, its own bar for user). */
-.copy-btn {
-  background: none; border: none; cursor: pointer; font-size: 0.85rem;
-  padding: 2px 6px; border-radius: 5px; line-height: 1; color: var(--text-fade);
-  -webkit-tap-highlight-color: transparent;
-}
-.copy-btn:hover { background: var(--accent-soft); color: var(--accent); }
-.copy-btn.copied { color: var(--good); }
-/* User bubbles are right-aligned, so right-align their copy bar too. */
-.msg.user .rate-bar { justify-content: flex-end; opacity: 0.4; }
-.msg.user:hover .rate-bar { opacity: 0.85; }
-/* Touch devices have no hover — keep the tools tappable/visible. */
-@media (hover: none) {
-  .rate-bar, .msg.user .rate-bar { opacity: 0.65; }
-}
-
-/* Quality floor: honor reduced-motion preference. */
-@media (prefers-reduced-motion: reduce) {
-  *, *::before, *::after {
-    animation-duration: 0.01ms !important;
-    animation-iteration-count: 1 !important;
-    transition-duration: 0.01ms !important;
-    scroll-behavior: auto !important;
-  }
-}
+.rate-btn:hover { filter: none; background: rgba(255,122,0,0.12); }
+.rate-btn.rated { filter: none; background: rgba(255,122,0,0.25); opacity: 1; }

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lyra"
-version = "0.3.0"
+version = "0.2.0"
 description = "Persistent, autonomous AI assistant"
 readme = "README.md"
 requires-python = ">=3.11"

tests/test_modes.py

@@ -1,212 +0,0 @@
-"""Conversation modes: tool gating, mode persistence, stack tracking + HUD."""
-from __future__ import annotations
-
-import importlib
-
-import pytest
-
-
-@pytest.fixture
-def lyra(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)
-    import lyra.modes as modes
-    importlib.reload(modes)
-    import lyra.tools as tools
-    importlib.reload(tools)
-    return memory, poker, modes, tools
-
-
-def _names(specs):
-    return {s["function"]["name"] for s in specs}
-
-
-def test_tool_gating_by_mode(lyra):
-    _, _, modes, tools = lyra
-    talk = _names(tools.specs(modes.TALK.tools))
-    cash = _names(tools.specs(modes.CASH.tools))
-
-    # Cash is the full live toolset.
-    assert {"log_hand", "log_stack", "analyze_spot", "end_session"} <= cash
-    # Talk hides the live write tools...
-    assert "log_hand" not in talk and "log_stack" not in talk
-    # ...but keeps her agency + read-only lookups + the session entry point.
-    assert {"journal_write", "note", "player_profile", "start_session"} <= talk
-    # No allow-list = every registered tool.
-    assert _names(tools.specs()) == set(tools.TOOLS)
-
-
-def test_every_mode_tool_exists(lyra):
-    _, _, modes, tools = lyra
-    for mode in modes.MODES.values():
-        assert set(mode.tools) <= set(tools.TOOLS), f"{mode.key} references unknown tools"
-
-
-def test_mode_resolution_and_persistence(lyra):
-    memory, _, modes, _ = lyra
-    assert modes.get(None).key == modes.DEFAULT
-    assert modes.get("nonsense").key == modes.DEFAULT
-    assert modes.get("poker_cash") is modes.CASH
-
-    memory.ensure_session("s1")
-    assert memory.get_session_mode("s1") is None  # unset -> caller applies default
-    memory.set_session_mode("s1", "poker_cash")
-    assert memory.get_session_mode("s1") == "poker_cash"
-    # set on an unknown session creates the row
-    memory.set_session_mode("s2", "conversation")
-    assert memory.get_session_mode("s2") == "conversation"
-
-
-def test_stack_log_and_live_net(lyra):
-    _, poker, _, _ = lyra
-    poker.start_session(venue="Meadows", stakes="2/5", buy_in=500)
-    assert poker.current_stack() is None  # nothing logged yet
-
-    st = poker.log_stack(700)
-    assert st["current"] == 700 and st["net"] == 200  # up 200 on a 500 buy-in
-    poker.log_stack(350)
-    assert poker.current_stack() == 350
-    assert poker.stack_state()["net"] == -150
-    assert len(poker.stack_log()) == 2
-
-
-def test_log_stack_requires_live_session(lyra):
-    _, poker, _, _ = lyra
-    with pytest.raises(ValueError):
-        poker.log_stack(300)
-
-
-def test_hud_bundle(lyra):
-    _, poker, _, _ = lyra
-    assert poker.hud() is None  # no session -> nothing to show
-
-    sid = poker.start_session(venue="Meadows", stakes="2/5", game="NLH", buy_in=500)
-    poker.log_stack(620)
-    poker.log_hand(position="BTN", hole_cards="AKs", result=120, tag="confidence")
-    poker.add_read(note="3bets light from the SB", name="Round Mike", seat="SB")
-
-    hud = poker.hud()
-    assert hud["session"]["id"] == sid and hud["session"]["stakes"] == "2/5"
-    assert hud["stack"]["current"] == 620 and hud["stack"]["net"] == 120
-    assert len(hud["stack"]["log"]) == 1
-    assert len(hud["hands"]) == 1 and hud["hands"][0]["hole_cards"] == "AKs"
-    assert any(v["name"] == "Round Mike" for v in hud["villains"])
-    assert hud["stats"]["hands_logged"] == 1
-
-
-def test_log_stack_tool_handler(lyra):
-    _, poker, _, tools = lyra
-    poker.start_session(stakes="1/3", buy_in=300)
-    out = tools.dispatch("log_stack", {"amount": 450}, {})
-    assert "450" in out and "150" in out  # confirms stack + live net
-    # graceful when there's no number
-    assert "number" in tools.dispatch("log_stack", {}, {}).lower()
-
-
-# --- mental-game rituals ---
-
-def test_ritual_tools_in_cash_only(lyra):
-    _, _, modes, tools = lyra
-    cash = _names(tools.specs(modes.CASH.tools))
-    talk = _names(tools.specs(modes.TALK.tools))
-    rituals = {"scar_note", "confidence_bank", "alligator_blood", "reset_ritual"}
-    assert rituals <= cash
-    assert not (rituals & talk)
-
-
-def test_scar_and_confidence_capture(lyra):
-    _, poker, _, tools = lyra
-    poker.start_session(stakes="2/5", buy_in=500)
-    tools.dispatch("scar_note", {"content": "punted bottom set", "classification": "punt"}, {})
-    tools.dispatch("scar_note", {"content": "ran KK into AA", "classification": "cooler"}, {})
-    tools.dispatch("confidence_bank", {"content": "disciplined river fold"}, {})
-
-    scars = poker.list_rituals(kinds=("scar",))
-    assert len(scars) == 2
-    assert {s["classification"] for s in scars} == {"punt", "cooler"}
-    conf = poker.list_rituals(kinds=("confidence",))
-    assert len(conf) == 1 and "fold" in conf[0]["content"]
-    # bogus classification is dropped, not stored
-    tools.dispatch("scar_note", {"content": "x", "classification": "nonsense"}, {})
-    assert poker.list_rituals(kinds=("scar",))[-1]["classification"] is None
-
-
-def test_alligator_toggle_and_state(lyra):
-    _, poker, _, tools = lyra
-    poker.start_session(stakes="2/5", buy_in=500)
-    assert poker.alligator_active() is False
-    tools.dispatch("alligator_blood", {"on": True}, {})
-    assert poker.alligator_active() is True
-    tools.dispatch("alligator_blood", {"on": False}, {})
-    assert poker.alligator_active() is False  # latest toggle wins
-
-
-def test_rituals_in_hud(lyra):
-    _, poker, _, tools = lyra
-    poker.start_session(stakes="2/5", buy_in=500)
-    tools.dispatch("scar_note", {"content": "overplayed top pair"}, {})
-    tools.dispatch("confidence_bank", {"content": "good value bet"}, {})
-    tools.dispatch("reset_ritual", {"content": "lost a flip"}, {})
-    tools.dispatch("alligator_blood", {"on": True}, {})
-
-    r = poker.hud()["rituals"]
-    assert r["alligator"] is True
-    assert len(r["scars"]) == 1 and len(r["confidence"]) == 1 and len(r["resets"]) == 1
-
-
-def test_session_state_readback(lyra):
-    _, poker, _, tools = lyra
-    assert "no live session" in tools.dispatch("session_state", {}, {}).lower()
-
-    poker.start_session(venue="Meadows", stakes="2/5", buy_in=500)
-    tools.dispatch("log_stack", {"amount": 720}, {})
-    tools.dispatch("confidence_bank", {"content": "great river fold"}, {})
-    tools.dispatch("alligator_blood", {"on": True}, {})
-
-    out = tools.dispatch("session_state", {}, {})
-    assert "720" in out            # current stack
-    assert "+220" in out or "220" in out  # live net
-    assert "Alligator Blood is ON" in out
-    assert "great river fold" in out
-
-
-def test_list_and_delete_session(lyra):
-    _, poker, _, tools = lyra
-    keep = poker.start_session(venue="Meadows", stakes="1/3", buy_in=300)
-    poker.end_session(cash_out=400, session_id=keep)
-    drop = poker.start_session(venue="Bellagio", stakes="2/5", buy_in=500)
-    poker.log_hand(position="BTN", hole_cards="AKs", session_id=drop)
-    poker.log_stack(620, session_id=drop)
-    poker.log_ritual("scar", content="punt", session_id=drop)
-
-    sessions = poker.list_sessions()
-    assert {s["id"] for s in sessions} == {keep, drop}
-    assert next(s for s in sessions if s["id"] == drop)["hands"] == 1
-
-    removed = poker.delete_session(drop)
-    assert removed["poker_sessions"] == 1 and removed["poker_hands"] == 1
-    assert removed["poker_stack_log"] == 1 and removed["poker_rituals"] == 1
-    assert {s["id"] for s in poker.list_sessions()} == {keep}  # only the survivor
-    assert poker.get_session(drop) is None
-
-
-def test_recent_sessions_tool(lyra):
-    _, poker, modes, tools = lyra
-    assert "recent_sessions" in modes.TALK.tools  # available even when just talking
-    poker.import_session(date="2026-06-01", venue="Meadows", stakes="1/3",
-                         buy_in_total=300, cash_out=520, hours=5)
-    out = tools.dispatch("recent_sessions", {}, {})
-    assert "Meadows" in out and "+220" in out
-
-
-def test_rituals_require_live_session(lyra):
-    _, poker, _, tools = lyra
-    # tools degrade gracefully (no exception) when nothing is open
-    assert "no live session" in tools.dispatch("scar_note", {"content": "x"}, {}).lower()
-    with pytest.raises(ValueError):
-        poker.log_ritual("scar", content="x")

uv.lock

@@ -278,7 +278,7 @@ wheels = [
 
 [[package]]
 name = "lyra"
-version = "0.3.0"
+version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },