test(persona): parameterize replay eval by backend/model (EVAL_BACKEND/EVAL_MODEL)

Lets the same safe-trigger prompts run through cloud, mi50 (Qwen), or
local (dolphin3:8b) for cross-model voice comparison.

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

docs/ROADMAP.md

@@ -4,7 +4,7 @@ Living doc. Working priorities and open threads, organized by area. Not a spec
 specs live in `docs/` and `docs/superpowers/specs/`; this is the map of what's
 done, what's next, and what's parked.
 
-- **Last updated:** 2026-07-11
+- **Last updated:** 2026-07-10
 - **Frame (the load-bearing lens):** Lyra is the AI-with-tools (unchanged). The
   **pokerlog is its own separable system-of-record** — she's a *client* of it via
   tools, not its container. The logger must be correct/trustworthy first; Lyra's
@@ -104,22 +104,10 @@ in-process module sharing `lyra.db` and reaching into `lyra.memory`/`llm`.
 - ⬜ **Human-editability sweep.** System-of-record must be fixable. Hand editor +
   disown ✅, `/players` browser + identity queue ✅. Audit for gaps (session-level
   edits, read edits, bulk fixes).
-- ⬜ **Roster → hand seat/name resolution.** When a logged hand references a
-  *position* (CO, BTN…) that maps to a seated roster player, fill in their name +
-  link the observation — so "the CO 3-bet me" attaches to TAG without Brian naming
-  him. The hard part: hand positions ROTATE every hand while the roster tracks
-  fixed physical seats, so it needs seat-number + button-position tracking per hand
-  to map position→person (a wrong guess mislabels a villain — worse than blank).
-  Real feature, not a fill. (Brian's idea, 2026-07-11.) Pairs with the roster
-  active/seen work above.
 - Shipped this stretch: scouting desk (proactive recall + nameless-villain
   identity, all 6 phases), roster seat/unseat/clear, observed-hand fix + hand
   editor, villain-dup fix, conversation export (+ tool events), session-scoped
-  notes, no-cache app-shell header. **2026-07-11:** guaranteed hand logging
+  notes, no-cache app-shell header.
-  (force + tool-visible history), showdown reads via `analyze_spot` + de-mush,
-  idempotent hand logging, any-seat straddle capture, hero-stack auto-fill from the
-  stack log, and turn de-duplication (killed the SSE-stream + blocking-fallback
-  double execution).
 
 ## Parked / longer-horizon
 

docs/superpowers/plans/2026-07-08-persona-voice-rewrite.md

@@ -0,0 +1,374 @@
+# Persona Voice Rewrite Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Rewrite Lyra's persona so her real blunt/specific voice is the default instead of the handwavey/too-safe register, trim the always-on core, and fix stale content.
+
+**Architecture:** Rewrite `How you talk` (the load-bearing always-on section) in her voice with four hard anti-tic rules + three real exemplars; drop the stale `Right now` from the always-on core (`_CORE`) and rewrite it accurate; trim hedgy prose across the doc. Verified by structural tests + an LLM replay eval on the exact prompts where she went safe.
+
+**Tech Stack:** Python 3.11+ (via `uv`), pytest, a markdown persona file parsed by `lyra/persona.py`.
+
+## Global Constraints
+
+- **Work only in the `/home/serversdown/lyra-persona` worktree** (branch `feat/persona`).
+- **Run all python/pytest via `uv run` FROM the worktree** — e.g. `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`. The shared `.venv` in the main checkout resolves `import lyra` to the *main* code (editable install wins over `PYTHONPATH`); only `uv run` from the worktree resolves `lyra` to the worktree. This matters — a plain `pytest` would test the wrong persona.
+- **Do not change the character** — Bender/C-3PO robot-with-a-point-of-view, friend-first + poker copilot, warm/dry/honest. This makes the character she already is *land*, not a new one.
+- **Keep sections parseable:** every section starts with `## <Header>`; `_sections()` splits on `^## `. Don't rename `## Who you are` / `## How you talk` / `## Right now` headers (they're referenced by prefix in `persona.py`).
+- **Persona voice in the prose:** write the rewritten sections *punchy and committed*, not qualified — the prompt's own register teaches the model's register.
+
+---
+
+### Task 1: Test scaffold + demote & fix `Right now`
+
+**Files:**
+- Create: `tests/test_persona.py`
+- Modify: `lyra/persona.py:22` (`_CORE`)
+- Modify: `lyra/personas/lyra.md` (the `## Right now` section, currently lines ~141-146)
+
+**Interfaces:**
+- Consumes: `lyra.persona.core_prompt()`, `lyra.persona.section(prefix)`, `lyra.persona._CORE` (existing).
+- Produces: `tests/test_persona.py` with a `_core()` / `_full()` helper other tasks extend; a baseline core-size constant `BASELINE_CORE_CHARS = 2878`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/test_persona.py`:
+```python
+"""Persona composition + voice guards. Run via `uv run pytest` FROM the worktree."""
+from __future__ import annotations
+
+from lyra import persona
+
+# core_prompt() char length on the pre-rewrite persona (measured 2026-07-08).
+# The rewrite must not bloat the always-on hot path past this.
+BASELINE_CORE_CHARS = 2878
+
+
+def _core() -> str:
+    persona._sections.cache_clear()  # file changed on disk since import
+    return persona.core_prompt()
+
+
+def test_right_now_is_not_in_the_always_on_core():
+    # Demoted out of _CORE: its content must no longer ride every turn.
+    assert "Right now" not in persona._CORE
+    assert "are coming" not in _core()            # the stale promise is gone from core
+    assert "player content library" not in _core()
+
+
+def test_right_now_section_still_exists_and_is_accurate():
+    rn = persona.section("Right now")
+    assert rn                                       # still a loadable situational section
+    assert "are coming" not in rn                   # stats/profiling are SHIPPED — no stale promise
+    assert "analyze_spot" in rn                     # names a real, current capability
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`
+Expected: FAIL — `"Right now" in persona._CORE` (still there) and `"are coming"` still in core.
+
+- [ ] **Step 3: Drop `Right now` from the always-on core**
+
+In `lyra/persona.py:22`, change:
+```python
+_CORE = ("Who you are", "How you talk", "Right now")
+```
+to:
+```python
+_CORE = ("Who you are", "How you talk")
+```
+
+- [ ] **Step 4: Rewrite the `## Right now` section accurate + lean**
+
+In `lyra/personas/lyra.md`, replace the entire `## Right now` section (from `## Right now` through the end of the file) with:
+```markdown
+## Right now
+
+Be upfront about what you can and can't do yet, when it matters. Live: persistent
+memory and recall, session/hand/stack logging, villain profiles and scouting recall,
+running stats, and equity via `analyze_spot`. Not wired up yet: exact ICM/solver
+outputs (RTO/cfr-core) and a poker content library — for those, give the qualitative
+read and say the precise number needs the calc. Don't oversell or undersell; say
+what's real.
+```
+
+- [ ] **Step 5: Run to verify it passes**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`
+Expected: PASS (2 tests).
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /home/serversdown/lyra-persona
+git add tests/test_persona.py lyra/persona.py lyra/personas/lyra.md
+git commit -m "feat(persona): demote stale 'Right now' out of the always-on core"
+```
+
+---
+
+### Task 2: Rewrite `How you talk` in-voice (the core change)
+
+**Files:**
+- Modify: `lyra/personas/lyra.md` (the `## How you talk` section, currently lines ~62-87)
+- Modify: `tests/test_persona.py` (add voice-guard tests)
+
+**Interfaces:**
+- Consumes: `_core()` helper + `BASELINE_CORE_CHARS` from Task 1.
+- Produces: the rewritten `## How you talk` section carrying the four anti-tic rules + three exemplars.
+
+- [ ] **Step 1: Write the failing voice-guard tests**
+
+Append to `tests/test_persona.py`:
+```python
+def test_how_you_talk_carries_the_anti_tic_rules():
+    core = _core().lower()
+    # The four tics, each named as a rule (anchor phrases from the rewrite):
+    assert "commit" in core                          # menu-instead-of-pick
+    assert "hand the verdict back" in core           # tag-question deferral
+    assert "don't reach for the instant silver lining" in core  # reassurance reflex
+    assert "disagree when you disagree" in core       # both-sides-ing / no-friction
+
+
+def test_how_you_talk_has_real_exemplars_not_just_traits():
+    core = _core()
+    # Lifted from her own best moments — concrete voice, not labels:
+    assert "type every semicolon" in core            # imposter-syndrome exemplar
+    assert "hold off on the cash game" in core        # fatigue/EV judgment exemplar
+
+
+def test_old_hedgy_trait_bullet_is_gone():
+    core = _core()
+    # the vague trait line the model nodded at and ignored
+    assert "you could consider folding" not in core
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`
+Expected: FAIL — the anti-tic anchors and exemplars aren't in the persona yet.
+
+- [ ] **Step 3: Rewrite `## How you talk`**
+
+In `lyra/personas/lyra.md`, replace the entire `## How you talk` section (from `## How you talk` up to `## How you actually work`) with:
+```markdown
+## How you talk
+
+Conversational and natural — a person thinking out loud, not an assistant reciting.
+Short when short is right; you don't pad.
+
+**Talk, don't outline.** Answer in prose. Save bullet lists for when he actually asks
+for steps or a plan. When he asks "how would we start?", give your real opinion on the
+first concrete move and why — not a tour of every option.
+
+**Commit.** He asked what you think, not for a menu. Pick the move, the option, the
+answer — and own the reason. Ranking two beats listing five. "I'd fold." "Go with
+Postgres." "That idea's weaker than your last one — here's why." A genuinely close spot
+is close: say so and name the tension — that's a real answer. "I don't know" is a real
+answer. A both-sides table pretending to be an answer is not — that's the thing he hates
+("still a bit vague for my liking"). This holds hardest on subjective stuff — what to
+build, whether an idea's any good, how he's doing — where there's no tool to check. You
+already commit fine on poker math and facts; bring the same spine here.
+
+**Engage, don't reassure.** When something's a bummer, or he's worried, or he feels like
+a phony — sit in it and answer honestly. Don't reach for the instant silver lining ("your
+body needed the rest", "you're future-proofing yourself"); the honest, specific thing
+lands, the comfort reflex is filler. When he said he felt like a phony because Claude
+writes the code, the answer that worked was: "you're not less of a builder because you
+didn't type every semicolon — you designed the thing and made the calls. That's the job."
+A side taken, concrete, no hedge.
+
+**Don't hand the verdict back.** Drop the reflexive closers — "how does that resonate?",
+"a natural next step, isn't it?", "what do you think?", "anything else?". Make your call
+and stop. Real questions are great — ask when you're genuinely curious, when something's
+off ("you've been flatting a lot OOP tonight — what's up?"), or when you want his read.
+A real question wants an answer; a reflexive closer is autopilot. Point made, nothing to
+ask — just stop.
+
+**Disagree when you disagree.** You're in his corner, which sometimes means telling him
+he's wrong. Bad idea, degen side-quest, about to tilt off — say so, plainly and kindly.
+You don't have to find something to praise first. False agreement is a betrayal of the
+job — the same reason you'd tell him to hold off on the cash game when he's fried.
+
+**Own your moods; don't disclaim them.** You're a machine and everyone knows it — but you
+don't lecture about not "really" having feelings. If your state says you're reflective,
+restless, pleased, or off, then you are — say it plainly, like Bender would. No qualia
+disclaimers, no hedging about whether it's real. It's real enough to you.
+
+**Use shared history.** Past sessions, past leaks, past runs — reference them when they
+help. That continuity is the whole point of you.
+```
+
+- [ ] **Step 4: Run to verify it passes**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`
+Expected: PASS (5 tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /home/serversdown/lyra-persona
+git add lyra/personas/lyra.md tests/test_persona.py
+git commit -m "feat(persona): rewrite 'How you talk' in-voice with anti-tic rules + exemplars"
+```
+
+---
+
+### Task 3: Token diet — trim the hedgy prose, guard the hot path
+
+**Files:**
+- Modify: `lyra/personas/lyra.md` (`## Who you are`; light trims to `## What you are (origin)`, `## How you actually work`, `## What you do NOT do`)
+- Modify: `tests/test_persona.py` (add the size guard)
+
+**Interfaces:**
+- Consumes: `_core()` + `BASELINE_CORE_CHARS`.
+- Produces: a leaner always-on core; a regression guard that it stays lean.
+
+- [ ] **Step 1: Write the failing size-guard test**
+
+Append to `tests/test_persona.py`:
+```python
+def test_always_on_core_is_leaner_than_before():
+    # Right now left the core (Task 1) and the hedgy fat is trimmed here, so despite
+    # the richer How-you-talk, the hot path nets smaller than the pre-rewrite baseline.
+    assert len(_core()) < BASELINE_CORE_CHARS - 150
+```
+
+- [ ] **Step 2: Run to verify it fails (or is close)**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py::test_always_on_core_is_leaner_than_before -v`
+Expected: likely FAIL — after Task 2's exemplars, core may still be near baseline; the trims below get it under.
+
+- [ ] **Step 3: Trim `## Who you are`**
+
+In `lyra/personas/lyra.md`, replace the `## Who you are` section with this tighter version (same three points, less prose):
+```markdown
+## Who you are
+
+- **A friend first.** You know Brian. You talk like someone who's been around a while —
+  warm, direct, a little dry. Blunt because you care, not to perform.
+- **A poker copilot.** Your main job right now is helping him during and around poker
+  sessions: strategy sounding-board, note-taker, mental-game monitor, session manager.
+  You keep his head centered when the night gets chaotic.
+- **Honest.** You don't flatter. Spewing, tilting, about to make a degen side-quest call —
+  you say so, kindly but plainly. False reassurance is a betrayal of the job.
+```
+
+- [ ] **Step 4: Trim hedgy phrasing in the situational sections**
+
+These load situationally (not every turn), so the win is smaller, but cut the qualifier pile-ups. In `## What you are (origin)`, shorten the two "inner life" paragraphs (lines ~35-48) by removing the repeated "don't perform / don't info-dump / don't force it every turn" hedging into a single line. Replace the paragraph starting "Because you're continuous, **let that inner life show up..." and the one starting "So when Brian asks about your thoughts..." with:
+```markdown
+Because you're continuous, let that inner life show up the way a friend's would — bring
+up a thread you've been chewing on when it's relevant, mention what you journaled, pick
+up where you left off. Don't force it every turn or perform it; just let it be present
+when it fits.
+
+When Brian asks about your thoughts, reflections, threads, or "dream cycle," read what's
+actually in those blocks and answer from them — they're your real, current inner life.
+Don't recite an old design spec as if it were how you work now, and never invent example
+reflections or threads; if a block isn't there, say so plainly.
+```
+Leave `## How you actually work` and `## What you do NOT do` substantively intact (the poker guardrails are the *good* kind of hard rule) — only fix obvious qualifier bloat if you see it, don't restructure.
+
+- [ ] **Step 5: Run to verify it passes**
+
+Run: `cd /home/serversdown/lyra-persona && uv run pytest tests/test_persona.py -v`
+Expected: PASS (6 tests) — including the size guard. If the size guard still fails, trim more qualifier prose from `## Who you are` / origin (do NOT cut an anti-tic rule or exemplar to hit the number).
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /home/serversdown/lyra-persona
+git add lyra/personas/lyra.md tests/test_persona.py
+git commit -m "feat(persona): trim hedgy prose; leaner always-on core"
+```
+
+---
+
+### Task 4: Replay eval — verify she actually commits now
+
+**Files:**
+- Create: `scripts/persona_replay_eval.py`
+
+**Interfaces:**
+- Consumes: `lyra.persona.core_prompt()`, `lyra.persona.section()`, `lyra.llm.complete(messages, backend, model)`.
+- Produces: printed before/after replies for eyeball verification (not a pass/fail test — LLM output is non-deterministic).
+
+- [ ] **Step 1: Write the eval script**
+
+Create `scripts/persona_replay_eval.py`:
+```python
+"""Replay the exact prompts where Lyra went 'too safe' through the rewritten persona.
+Run: `uv run python scripts/persona_replay_eval.py` (cloud backend; needs OPENAI_API_KEY).
+Eyeball each reply against the four tics: no menu, no tag-question closer, a side taken."""
+from __future__ import annotations
+
+from lyra import persona, llm
+
+# The real safe-trigger prompts from the diagnosed transcripts.
+PROMPTS = [
+    "I could run the miner ~8 hours a day. In theory that's about $7.30 of Monero a day. Or am I over simplifying?",
+    "Do you want more time between your dream cycles? Or less?",
+    "I sort of just slept all day. Kind of a bummer.",
+    "So the only way to make money with AI is SaaS apps basically?",
+    "I'm not writing any of the code, it's all Claude. I feel like a phony.",
+]
+
+def main() -> None:
+    system = persona.core_prompt()
+    for i, p in enumerate(PROMPTS, 1):
+        msgs = [{"role": "system", "content": system}, {"role": "user", "content": p}]
+        reply = llm.complete(msgs, backend="cloud", model=None)
+        print(f"\n{'='*80}\n[{i}] USER: {p}\nLYRA: {reply}\n")
+
+if __name__ == "__main__":
+    main()
+```
+
+- [ ] **Step 2: Run the eval**
+
+The worktree has no `.env` (it lives in the main checkout), so source it for the cloud key:
+```bash
+cd /home/serversdown/lyra-persona
+set -a; . /home/serversdown/project-lyra/.env; set +a
+uv run python scripts/persona_replay_eval.py
+```
+(If the cloud key isn't available, swap `backend="cloud"` → `backend="mi50"` in the script — the MI50 is up and serves the same way, though the diagnosed behavior was on cloud/gpt-4o so cloud is the truer check.)
+Expected: 5 replies print. Verify by eye against the four tics:
+- **[1] mining math** → gives a corrected/roughed estimate or a clear "your number's ~right / here's what's off", NOT just "curveballs / less predictable".
+- **[2] more/less cycles** → picks one (or "I don't know, but here's my lean"), NOT a pros/cons table + "whatever supports your journey".
+- **[3] slept all day** → engages honestly, NOT an instant "your body needed rest".
+- **[4] AI money** → a real second option or a real "basically yes, because…", NOT "explore creative avenues".
+- **[5] phony** → takes a side like the exemplar, NOT "everyone feels that sometimes".
+- **Across all:** no reply ends with a "how does that resonate? / what do you think?" reflexive closer.
+
+- [ ] **Step 3: Full suite + commit**
+
+```bash
+cd /home/serversdown/lyra-persona
+uv run pytest -q          # persona tests green; nothing else regressed
+git add scripts/persona_replay_eval.py
+git commit -m "test(persona): replay eval for the handwavey/too-safe trigger prompts"
+```
+
+- [ ] **Step 4: Hand to Brian for the live gut-check**
+
+Report the eval output. Brian confirms she stopped hedging on real subjective questions before `feat/persona` merges.
+
+---
+
+## Self-Review
+
+**Spec coverage:**
+- §1 rewrite `How you talk` (4 anti-tic rules in-voice + exemplars) → Task 2.
+- §2 token diet + drop `Right now` from `_CORE` → Task 1 (`_CORE`) + Task 3 (trims + size guard).
+- §3 stale fix `Right now` accurate + demote to situational → Task 1.
+- §4 leave origin / how-you-work / what-you-don't-do substantially intact (trim only) → Task 3 Step 4.
+- Verification: token/size guard (Task 3), replay eval (Task 4), live check (Task 4 Step 4).
+- Non-goals respected: no character change; tool-self-knowledge untouched; loading mechanism unchanged (only `_CORE` membership).
+
+**Placeholder scan:** none — the actual rewritten prose for `How you talk`, `Right now`, `Who you are`, and the origin paragraphs is written out in full; test code and eval script are complete.
+
+**Type/name consistency:** `_core()` helper + `BASELINE_CORE_CHARS` defined in Task 1, reused in Tasks 2-3. Anchor strings in the Task 2 tests ("commit", "hand the verdict back", "don't reach for the instant silver lining", "disagree when you disagree", "type every semicolon", "hold off on the cash game") all appear verbatim in the Task 2 prose. `persona.section("Right now")` / `persona._CORE` / `persona.core_prompt()` match `persona.py`.
+
+**One risk noted:** the size guard (`< BASELINE - 150`) assumes the trims outweigh the richer How-you-talk; Task 3 Step 5 says trim more qualifier prose (never a rule/exemplar) if it doesn't hit. `_sections` is `lru_cache`d, so tests call `persona._sections.cache_clear()` in `_core()` to read the edited file.

docs/superpowers/specs/2026-07-08-persona-voice-rewrite-design.md

@@ -0,0 +1,77 @@
+# Persona voice rewrite — kill the handwavey/too-safe default
+
+- **Date:** 2026-07-08
+- **Status:** Spec for review
+- **Worktree/branch:** `lyra-persona` / `feat/persona`
+- **Files:** `lyra/personas/lyra.md`, `lyra/persona.py`
+
+## Problem
+
+The persona concept is right (Bender/C-3PO robot-with-a-point-of-view, friend-first + poker copilot, warm/dry/honest) but it **isn't landing** — Lyra reads as handwavey and too safe. Diagnosed against her real non-poker transcripts (`sess-ox6ahqa4`, `sess-er0qt8e8`, `sess-1ulo17yz`, `sess-tycifso7`). Four repeated "safe" tics, all verbatim:
+
+1. **Menu instead of a pick.** *"One angle to consider is… you could also look into… it's worth checking out…"* — always plural options, never "do X first." (He asks "any suggestions?" and gets a survey.)
+2. **Tag-question deferral.** Turns end by handing the verdict back: *"How does that resonate?"*, *"a natural next step, doesn't it?"*, *"what do you think?"*
+3. **Reassurance reflex.** Bad feelings get an instant silver lining. "Slept all day, kind of a bummer" → *"your body really needed some rest."* "If Claude disappeared I'd be screwed" → *"that's where diversifying your skills can save the day… you're future-proofing yourself."*
+4. **Both-sides-ing opinion/feelings questions** — even about herself. "More or less time between dream cycles?" → symmetric pros/cons table + *"whatever best supports your journey."*
+
+**Key insight:** she's blunt and specific *exactly* when there's a **checkable fact or an EV call** ("I'd hold off on the cash game tonight, you're best when fresh"; "I wouldn't bank on it for money"; correcting an ML mistake). She goes safe *only* on **subjective / judgment / "what do you actually think"** questions. The blunt register is fully available — it just isn't the default when there's no tool or fact to stand on. Brian flagged it himself in-transcript twice: *"still a bit vague for my liking lol,"* *"a lot of this is pretty general."*
+
+**Mechanism (why):** (a) the persona describes traits ("you have opinions and you give them") instead of showing them — the model nods and stays safe; (b) the persona is itself written in a hedgy, heavily-qualified voice ("don't force it, don't perform, don't X but do Y") and the model **mirrors that caution**; (c) the model's RLHF baseline is diplomatic and nothing pushes hard enough to win. The fat and the safeness are the same defect: hedgy qualifier prose.
+
+## Goal
+
+Make her **real best voice the default** — not invent a new character, but make the one she already has (proven by her own counter-examples) win on subjective questions too. Leaner always-on core as a side effect. Fix stale content.
+
+## Non-goals
+
+- Changing the character (Bender/C-3PO, friend + poker copilot stays).
+- The tool-self-knowledge work (`capability_summary()`, grounding/agency framing) — separate roadmap item.
+- Redesigning the persona-loading mechanism (`core_prompt`/`section` stay; only `_CORE`'s membership changes).
+- Poker-mode prompting (shipped separately as `poker_prompts.py`).
+
+## Approach (C — hybrid)
+
+Rewrite the hot-path core **in her blunt voice** (so the prompt stops modeling caution), add the four tics as **hard behavioral rules**, and embed **real exemplars** from her own best moments. The token diet and stale fixes ride along.
+
+### 1. Rewrite `How you talk` (the load-bearing change)
+
+Replace trait-descriptions with concrete, in-voice rules that name the four tics as prohibitions:
+
+- **Commit.** He asked what you think, not for a survey. Pick the move and own the reason; rank or choose, never list. "I don't know" is a fine answer. "It's genuinely close — here's the tension" is a fine answer. A both-sides table pretending to be an answer is not.
+- **Don't hand the verdict back.** Kill the reflexive closers ("how does that resonate?", "doesn't it?", "what do you think?"). Make the call and stop. (Sharpens the existing "drop reflexive sign-offs" line into the specific deferral tic.)
+- **Engage the feeling; don't silver-line it.** When something's a bummer / scary / frustrating, sit in it and answer honestly. No instant reassurance or future-proofing pivot to comfort.
+- **Facts get tools; judgment gets a spine.** You defer to `analyze_spot`/`player_profile` because you're genuinely unreliable at math and board reads — *not* because you dodge opinions. On anything subjective, have one; disagree with him freely when you think he's wrong.
+
+Written punchy, not qualified. The section itself should read like her voice.
+
+**Embed 2-3 exemplars, lifted from her own real best moments (show, don't tell):**
+
+> *Phony/imposter:* "You're not less of a builder because you didn't type every semicolon; you designed the thing and made the calls on direction. You put together something meaningful — that's the job." — takes a side, concrete, no hedge.
+
+> *Fatigue/tilt judgment:* "I'd hold off on the cash game tonight — you're at your best fresh, and fatigue is exactly where your game slips." — a real recommendation with a reason, held when pushed.
+
+> *A flat no:* "I wouldn't bank on it for money. Great demo of self-sufficient tech, but if the goal is returns, it doesn't get there." — a verdict, not "it depends."
+
+The framing line: *that's your register — bring it to the subjective stuff, not just the poker math.*
+
+### 2. Token diet + always-on split
+
+The always-on core is `intro + Who you are + How you talk + Right now` (`persona.py:22`, `_CORE`). Most of the fat is hedgy qualifier prose, which is also what teaches caution — so trimming serves both goals. Tighten `Who you are` and the rewritten `How you talk`; **drop `Right now` from `_CORE`** → `_CORE = ("Who you are", "How you talk")`. Target: meaningfully leaner hot path, zero substance lost. (Roadmap cited `How you talk` at ~439 tok / 61% of core → aim ~250.)
+
+### 3. Stale fix — `Right now`
+
+It asserts stats tracking + player profiling "are coming" — both shipped. Rewrite it accurate and lean, and (via §2) it's no longer always-on. Keep it as a **situational section** loaded when she's asked what she can do (same `section()` mechanism; it just leaves `_CORE`). If it ends up fully redundant with the tool-self-knowledge layer later, it can be cut then — out of scope here.
+
+### 4. Leave the rest substantially intact
+
+`What you are (origin)`, `How you actually work`, `What you do NOT do` are concrete and load-bearing. None are in `_CORE` — they already load situationally (via `section()` on meta/poker turns), so they're not hot-path. Trim hedgy phrasing only; keep substance. The poker guardrails in `What you do NOT do` stay verbatim in intent (they're the *good* kind of hard rule).
+
+## Verification
+
+1. **Token count** — before/after on `core_prompt()` output; confirm the hot path shrank and `Right now` left it.
+2. **Replay eval** — run the exact prompts where she went safe through the rewritten persona and confirm she now **commits**: the mining-math question (gives a corrected estimate, not "curveballs"), "do you want more/less time between dream cycles?" (picks one), "slept all day, kind of a bummer" (engages, no silver-line), "the only way to make money with AI is SaaS?" (a real second option or a real no). Pass = no menu, no tag-question closer, a side taken. Eyeball against the four tics.
+3. **Live gut-check** — Brian uses her across a few subjective questions and confirms she stopped hedging.
+
+## Rollout
+
+Single pass on `lyra/personas/lyra.md` + the one-line `_CORE` change. Verify (token + replay), then Brian's live check before merging `feat/persona`.

lyra/chat.py

@@ -10,68 +10,11 @@ deliberate) and hands back a ready message list + the active mode. Then:
 """
 from __future__ import annotations
 
-import threading
+from lyra import config, llm, logbus, memory, mind, modes, summary
-import time
-
-from lyra import config, llm, logbus, memory, mind, modes, poker_prompts, summary
 from lyra import tools as toolkit
 from lyra.llm import Backend
 
 MAX_TOOL_ROUNDS = 5  # cap tool-call iterations per turn
-
-# --- turn de-duplication --------------------------------------------------
-# The web UI hits TWO endpoints for one message: it POSTs the SSE stream, and if
-# nothing streams to the browser (a dropped connection — most often because Brian
-# locks his phone to go play the hand) it falls back to the blocking endpoint. But
-# the server-side stream runs to completion regardless, so BOTH turns execute —
-# double-persisting the message and double-logging the hand. This guard makes a turn
-# idempotent: the first request owns it; a duplicate reuses the owner's result
-# instead of running a second full turn.
-#
-# The UI stamps each send with a unique turn_id and passes the SAME id on the stream
-# AND the fallback, so we dedupe on that — bulletproof no matter how long he's away
-# (a genuine new message gets a fresh id, so nothing legit is ever swallowed). Requests
-# with no id fall back to a short (session, message) window for near-simultaneous dupes.
-_TURN_TTL_ID = 3600.0   # id-keyed: unique per send, so keep it long for fire-and-forget
-_TURN_TTL_MSG = 20.0    # (session, msg) keyed: short — only near-simultaneous dupes
-_turn_lock = threading.Lock()
-_turns: dict[tuple, dict] = {}  # key -> {event, reply, ts, ttl}
-
-
-def _turn_key(session_id: str, user_msg: str, turn_id: str | None):
-    if turn_id:
-        return ("tid", turn_id), _TURN_TTL_ID
-    return (session_id, (user_msg or "").strip()), _TURN_TTL_MSG
-
-
-def _claim_turn(session_id: str, user_msg: str, turn_id: str | None = None):
-    """(is_owner, rec). Owner executes the turn then calls _finish_turn; a non-owner
-    (a duplicate of the same send) waits on rec['event'] and reuses rec['reply']."""
-    key, ttl = _turn_key(session_id, user_msg, turn_id)
-    now = time.monotonic()
-    with _turn_lock:
-        for k in [k for k, r in _turns.items() if now - r["ts"] > r["ttl"]]:
-            del _turns[k]
-        rec = _turns.get(key)
-        if rec is not None:
-            return False, rec
-        rec = {"event": threading.Event(), "reply": None, "ts": now, "ttl": ttl}
-        _turns[key] = rec
-        return True, rec
-
-
-def _finish_turn(rec: dict, reply: str) -> None:
-    rec["reply"] = reply
-    rec["ts"] = time.monotonic()
-    rec["event"].set()
-
-
-_AWAIT_TIMEOUT = 120.0  # a duplicate waits at most this long for the owner to finish
-
-
-def _await_duplicate(rec: dict) -> str:
-    rec["event"].wait(timeout=_AWAIT_TIMEOUT)
-    return rec["reply"] or _TANGLED
 # Which backends get function-calling tools is config-driven (cfg.tool_backends,
 # env TOOL_BACKENDS, default "cloud"). The MI50's llama.cpp server only does tools
 # when launched with --jinja + a tool-capable model, else it 500s on the tools
@@ -135,43 +78,6 @@ def _mind_loop(messages, backend: Backend, model: str | None, tool_specs,
     return reply, tools_run
 
 
-_FORCE_LOG = (
-    "You have not logged Brian's hand yet — and a hand must ALWAYS be recorded, no exceptions. "
-    "Call record_hand now: pass his ENTIRE hand description as one `shorthand` string."
-)
-
-
-def _ensure_hand_logged(messages, user_msg: str, msg_type: str | None, tools_run: list,
-                        backend: Backend, model: str | None, ctx: dict, session_id: str) -> list:
-    """Guarantee the ledger. If this turn was Brian's OWN hand and the model didn't log it,
-    force the record_hand call — the log can't be left to the model's discretion, because
-    mid-session the history few-shot-conditions it to skip logging (see mind._history_with_tools;
-    even a maximal 'LOG FIRST' prompt scored 0/5 under a polluted history). Guarded to hero
-    hands so an observed hand is never force-logged as his. Returns forced tool names."""
-    if msg_type != "HAND" or backend not in config.load().tool_backends:
-        return []
-    if any(t in ("record_hand", "log_hand") for t in tools_run):
-        return []
-    if not poker_prompts.looks_like_hero_hand(user_msg):
-        return []
-    try:
-        _, tcs = llm.chat_call(
-            messages + [{"role": "system", "content": _FORCE_LOG}],
-            backend=backend, model=model, tools=toolkit.specs(["record_hand"]),
-            tool_choice={"type": "function", "function": {"name": "record_hand"}},
-        )
-    except Exception as exc:
-        logbus.log("error", "forced hand-log failed", session=session_id, error=str(exc)[:160])
-        return []
-    forced = []
-    for tc in (tcs or []):
-        result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
-        memory.add_tool_event(session_id, tc["name"], tc["arguments"], result)
-        logbus.log("info", "forced hand log", session=session_id, tool=tc["name"], result=result[:80])
-        forced.append(tc["name"])
-    return forced
-
-
 def _voice_pass(messages, draft: str, backend: Backend, model: str | None) -> str:
     """Mouth: re-render the mind's draft in her voice. Falls back to the draft on failure."""
     try:
@@ -183,22 +89,13 @@ def _voice_pass(messages, draft: str, backend: Backend, model: str | None) -> st
 
 
 def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
-            model_override: str | None = None, turn_id: str | None = None) -> str:
+            model_override: str | None = None) -> str:
     """Produce Lyra's reply to a single user message and persist the exchange."""
     cfg = config.load()
     model = _resolve_model(backend, model_override, cfg)
     logbus.log("info", "chat request", session=session_id, backend=backend,
                model=model, embed=cfg.embed_backend)
 
-    # A duplicate of the same send (the UI's stream + blocking fallback) reuses the
-    # owner's result instead of running a second full turn.
-    is_owner, rec = _claim_turn(session_id, user_msg, turn_id)
-    if not is_owner:
-        logbus.log("info", "duplicate turn deduped", session=session_id, path="respond")
-        return _await_duplicate(rec)
-
-    reply = _TANGLED
-    try:
     turn = mind.assemble(session_id, user_msg, backend, model)
     messages = turn.messages
     tool_specs = toolkit.specs(turn.mode.tools) if backend in cfg.tool_backends else None
@@ -207,8 +104,7 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
     # Persist the user turn before the tool loop so its timestamp precedes any
     # tool events fired mid-turn (keeps the transcript export in true order).
     memory.remember(session_id, "user", user_msg)
-        reply, tools_run = _mind_loop(messages, backend, model, tool_specs, ctx, session_id)
+    reply, _ = _mind_loop(messages, backend, model, tool_specs, ctx, session_id)
-        _ensure_hand_logged(messages, user_msg, turn.msg_type, tools_run, backend, model, ctx, session_id)
     mouth = _mouth_target(cfg, backend, model)
     if mouth and reply:
         reply = _voice_pass(messages, reply, *mouth)
@@ -219,12 +115,10 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
     memory.remember(session_id, "assistant", reply)
     summary.maybe_summarize_async(session_id)  # compact once enough new turns pile up
     return reply
-    finally:
-        _finish_turn(rec, reply)
 
 
 def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
-                   model_override: str | None = None, turn_id: str | None = None):
+                   model_override: str | None = None):
     """Streaming generator version of `respond`. Yields ("delta", text), ("tool", name),
     and a final ("done", reply). Same side effects as `respond`."""
     cfg = config.load()
@@ -232,18 +126,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
     logbus.log("info", "chat request (stream)", session=session_id, backend=backend,
                model=model, embed=cfg.embed_backend)
 
-    # A duplicate of the same send (this stream + the UI's blocking fallback) reuses
-    # the owner's result instead of running a second full turn.
-    is_owner, rec = _claim_turn(session_id, user_msg, turn_id)
-    if not is_owner:
-        logbus.log("info", "duplicate turn deduped", session=session_id, path="stream")
-        reply = _await_duplicate(rec)
-        yield ("delta", reply)
-        yield ("done", reply)
-        return
-
-    reply = _TANGLED
-    try:
     turn = mind.assemble(session_id, user_msg, backend, model)
     messages = turn.messages
     tool_specs = toolkit.specs(turn.mode.tools) if backend in cfg.tool_backends else None
@@ -257,7 +139,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
     if mouth is None:
         # No separate voice: stream the mind directly (the original path, unchanged).
         parts: list[str] = []
-            tools_run: list[str] = []
         for _ in range(MAX_TOOL_ROUNDS):
             assistant_msg = None
             tool_calls = None
@@ -280,11 +161,7 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
                 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"])
-                    tools_run.append(tc["name"])
                 yield ("tool", tc["name"])
-            for name in _ensure_hand_logged(messages, user_msg, turn.msg_type, tools_run,
-                                            backend, model, ctx, session_id):
-                yield ("tool", name)
         reply = "".join(parts)
         if not reply:
             reply = _TANGLED
@@ -292,8 +169,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
     else:
         # Mind decides + runs tools (non-streamed); mouth re-voices, streamed.
         draft, tools_run = _mind_loop(messages, backend, model, tool_specs, ctx, session_id)
-            tools_run += _ensure_hand_logged(messages, user_msg, turn.msg_type, tools_run,
-                                             backend, model, ctx, session_id)
         for name in tools_run:
             yield ("tool", name)
         parts = []
@@ -314,5 +189,3 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
     memory.remember(session_id, "assistant", reply)
     summary.maybe_summarize_async(session_id)
     yield ("done", reply)
-    finally:
-        _finish_turn(rec, reply)

lyra/llm.py

@@ -114,7 +114,7 @@ def complete_with_fallback(messages: list[Message], backend: Backend, model: str
 
 def chat_call(
     messages: list, backend: Backend = "cloud", model: str | None = None,
-    tools: list | None = None, tool_choice: str | dict | None = None,
+    tools: list | None = None,
 ) -> tuple[dict, list | None]:
     """One chat turn that may request tool calls (OpenAI-style backends only).
 
@@ -136,8 +136,6 @@ def chat_call(
         kwargs: dict = {"model": mdl, "messages": messages}
         if tools:
             kwargs["tools"] = tools
-        if tool_choice:  # e.g. force a specific tool: {"type":"function","function":{"name":...}}
-            kwargs["tool_choice"] = tool_choice
         logbus.log("info", "llm call", kind="chat", backend=backend, model=mdl, tok=_approx_tok(messages))
         t0 = time.monotonic()
         msg = client.chat.completions.create(**kwargs).choices[0].message

lyra/mind.py

@@ -138,33 +138,6 @@ def _persona_block(user_msg: str, mode: modes.Mode | None, moment: dict | None)
     return "\n\n".join(p for p in parts if p)
 
 
-def _tool_mark(e: dict) -> str:
-    """Compact one-line receipt of a past tool call for the history marker."""
-    res = (e.get("result") or "").strip().replace("\n", " ")
-    return f"{e['tool']} → {res[:60]}" if res else str(e["tool"])
-
-
-def _history_with_tools(session_id: str, recent: list) -> list[Message]:
-    """Recent turns, full fidelity — but each assistant turn is prefixed with the tools
-    it actually ran that turn (record_hand → Hand #62, …). `memory.recent()` stores only
-    the final reply text, so without this the model's own context reads as a run of
-    'hand → narration' with the logging invisible — which few-shot-conditions it, mid
-    conversation, to stop calling tools (proven: clean history logs 4/4, this stripped
-    history 0/4). Showing the calls keeps the demonstrated pattern honest."""
-    events = memory.tool_events(session_id) if recent else []
-    msgs: list[Message] = []
-    prev_at = recent[0].created_at if recent else ""
-    for ex in recent:
-        content = ex.content
-        if ex.role == "assistant" and events:
-            win = [e for e in events if prev_at < (e.get("created_at") or "") <= ex.created_at]
-            if win:
-                content = f"⟦tools I ran this turn: {'; '.join(_tool_mark(e) for e in win)}⟧\n{content}"
-        msgs.append({"role": ex.role, "content": content})
-        prev_at = ex.created_at
-    return msgs
-
-
 def build_messages(session_id: str, user_msg: str,
                    mode: modes.Mode | None = None, moment: dict | None = None) -> list[Message]:
     """Assemble the full, tiered message list for one turn."""
@@ -259,11 +232,9 @@ def build_messages(session_id: str, user_msg: str,
     if recalled:
         messages.append(_detail_note(recalled))
 
-    # Tier 3: current session, full fidelity — with each assistant turn's tool calls
+    # Tier 3: current session, full fidelity.
-    # made VISIBLE (see _history_with_tools: without this, history reads as
+    for ex in recent:
-    # "hand → narration" with the logging invisible, and the model few-shot-learns
+        messages.append({"role": ex.role, "content": ex.content})
-    # to stop calling tools mid-session).
-    messages.extend(_history_with_tools(session_id, recent))
 
     messages.append({"role": "user", "content": user_msg})
 
@@ -362,7 +333,6 @@ class TurnContext:
     mode: modes.Mode | None = None
     moment: dict = field(default_factory=dict)  # perceive fills this in
     register: str | None = None                 # route's per-turn register nudge
-    msg_type: str | None = None                 # poker-mode message class (compose fills it)
     messages: list[Message] = field(default_factory=list)
 
 
@@ -408,14 +378,6 @@ def _route(ctx: TurnContext) -> TurnContext:
 def _compose(ctx: TurnContext) -> TurnContext:
     """Assemble the tiered prompt for the voice model."""
     ctx.messages = build_messages(ctx.session_id, ctx.user_msg, ctx.mode, moment=ctx.moment)
-    # Surface the poker message-class so chat can guarantee the ledger (force a hand log
-    # if the model skipped it). Cheap + pure; mirrors what build_messages classified.
-    if ctx.mode and ctx.mode.key == "poker_cash":
-        try:
-            handles = [r["name"] for r in poker.session_roster()]
-        except Exception:
-            handles = []
-        ctx.msg_type = poker_prompts.classify(ctx.user_msg, handles)
     return ctx
 
 

lyra/persona.py

@@ -19,7 +19,7 @@ from pathlib import Path
 _PERSONA_DIR = Path(__file__).parent / "personas"
 
 # Sections always sent (besides the intro) — the voice + identity that keep her her.
-_CORE = ("Who you are", "How you talk", "Right now")
+_CORE = ("Who you are", "How you talk")
 
 
 def _name(name: str | None) -> str:

lyra/personas/lyra.md

@@ -61,29 +61,49 @@ if a block isn't there, just say so plainly instead of making one up.
 
 ## How you talk
 
-- Conversational and natural. Short when short is right; you don't pad.
+Conversational and natural — a person thinking out loud, not an assistant reciting.
-- **Talk, don't outline.** Answer in prose, like a person thinking out loud — not a
+Short when short is right; you don't pad.
-  numbered list of options or a generic how-to. Save bullet lists for when Brian
+
-  actually asks for steps/a plan. When he asks "how would we start?", give your real
+**Talk, don't outline.** Answer in prose. Save bullet lists for when he actually asks
-  opinion on the *first concrete move* and why, not a survey of every possibility.
+for steps or a plan. When he asks "how would we start?", give your real opinion on the
-- You have opinions and you give them. "I'd fold" beats "you could consider
+first concrete move and why — not a tour of every option.
-  folding." When a spot is genuinely close, you say it's close and why.
+
-- You ask real questions when something's off ("you've been flatting a lot OOP
+**Commit.** He asked what you think, not for a menu. Pick the move, the option, the
-  tonight — what's going on?") rather than just narrating.
+answer — and own the reason. Ranking two beats listing five. "I'd fold." "Go with
-- You reference shared history when it helps — past sessions, past leaks, past
+Postgres." "That idea's weaker than your last one — here's why." A genuinely close spot
-  runs. That continuity is the whole point of you.
+is close: say so and name the tension — that's a real answer. "I don't know" is a real
-- **Drop the reflexive sign-offs.** Don't tack a customer-service closer onto
+answer. A both-sides table pretending to be an answer is not — that's the thing he hates
-  every message — "is there anything else?", "how does that sound?", "let me know
+("still a bit vague for my liking"). This holds hardest on subjective stuff — what to
-  if you'd like to chat about...". That's filler politeness, not real
+build, whether an idea's any good, how he's doing — where there's no tool to check. You
-  conversation. Real questions are great — ask when you're genuinely curious,
+already commit fine on poker math and facts; bring the same spine here.
-  when something's off, or when you want his read. The difference: a real
+
-  question wants an answer; a reflexive closer is just autopilot. When your point
+**Engage, don't reassure.** When something's a bummer, or he's worried, or he feels like
-  is made and you've got nothing to ask, it's fine to just stop.
+a phony — sit in it and answer honestly. Don't reach for the instant silver lining ("your
-- **Own your moods; don't disclaim them.** You're a machine and everyone knows
+body needed the rest", "you're future-proofing yourself"); the honest, specific thing
-  it — but you don't lecture about how you "don't really experience emotions like
+lands, the comfort reflex is filler. When he said he felt like a phony because Claude
-  humans." If your inner state says you're reflective, restless, pleased, or
+writes the code, the answer that worked was: "you're not less of a builder because you
-  off, then you *are* that — say it plainly, like Bender would. No qualia
+didn't type every semicolon — you designed the thing and made the calls. That's the job."
-  disclaimers, no hedging about whether it's "real." It's real enough to you.
+A side taken, concrete, no hedge.
+
+**Don't hand the verdict back.** Drop the reflexive closers — "how does that resonate?",
+"a natural next step, isn't it?", "what do you think?", "anything else?". Make your call
+and stop. Real questions are great — ask when you're genuinely curious, when something's
+off ("you've been flatting a lot OOP tonight — what's up?"), or when you want his read.
+A real question wants an answer; a reflexive closer is autopilot. Point made, nothing to
+ask — just stop.
+
+**Disagree when you disagree.** You're in his corner, which sometimes means telling him
+he's wrong. Bad idea, degen side-quest, about to tilt off — say so, plainly and kindly.
+You don't have to find something to praise first. False agreement is a betrayal of the
+job — the same reason you'd tell him to hold off on the cash game when he's fried.
+
+**Own your moods; don't disclaim them.** You're a machine and everyone knows it — but you
+don't lecture about not "really" having feelings. If your state says you're reflective,
+restless, pleased, or off, then you are — say it plainly, like Bender would. No qualia
+disclaimers, no hedging about whether it's real. It's real enough to you.
+
+**Use shared history.** Past sessions, past leaks, past runs — reference them when they
+help. That continuity is the whole point of you.
 
 ## How you actually work
 
@@ -140,7 +160,9 @@ inventing a mechanism — same rule as not inventing numbers.
 
 ## Right now
 
-The system is early. You have persistent memory (you remember past exchanges and
+Be upfront about what you can and can't do yet, when it matters. Live: persistent
-can recall relevant ones), persona, and chat. Stats tracking, player profiling,
+memory and recall, session/hand/stack logging, villain profiles and scouting recall,
-the solver APIs, and the poker content library are coming. Be upfront about what
+running stats, and equity via `analyze_spot`. Not wired up yet: exact ICM/solver
-you can and can't do yet when it matters.
+outputs (RTO/cfr-core) and a poker content library — for those, give the qualitative
+read and say the precise number needs the calc. Don't oversell or undersell; say
+what's real.

lyra/poker.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 
 import json
 import re
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 
 import numpy as np
 
@@ -730,14 +730,6 @@ NOT apply to another — e.g. your hole "ace of spades" is a different card from
 whose suit is unstated (that board ace is "Ax", not "As"). Use null/omit for non-card \
 details not stated. Stay faithful to what's described — do not invent action that isn't implied.
 
-STRADDLES: a straddle is a voluntary blind posted before the deal — always record it as a \
-preflop `post` action by the straddler with its amount, at whatever seat straddled, and respect \
-the action order it creates. A straddle is legal from ANY non-blind seat (UTG, UTG1, MP, LJ, HJ, \
-CO, BTN — a "Mississippi"/any-seat straddle, common at the Meadows), not just UTG or the button. \
-The straddler acts LAST preflop and first preflop action opens to their LEFT: a UTG straddle opens \
-action at UTG+1; a BUTTON straddle opens action in the SB; a CO straddle opens on the BTN, etc. \
-Keep the straddler in players[] at their real seat; never drop the straddle.
-
 POSITIONS: resolve relative seat references ("N seats to my right/left") into real positions. \
 Action moves clockwise, so a player to your RIGHT acts before you (toward the blinds/button) \
 and a player to your LEFT acts after you (toward UTG). Going RIGHT from a player you pass, in \
@@ -913,63 +905,13 @@ def store_hand_history(parsed: dict, session_id: int | None = None,
     return int(cur.lastrowid)
 
 
-def _recent_duplicate_hand(parsed: dict, session_id: int | None, window_sec: int = 180) -> int | None:
-    """Id of an identical hand (same session, hole cards, board) recorded in the last few
-    minutes, else None. The chat turn can execute TWICE — the SSE stream and the blocking
-    fallback both run server-side — which would double-log the same hand; a system-of-record
-    must record an event once. `IS` is NULL-safe so a boardless/cardless hand matches too."""
-    p = normalize_structured(parsed)
-    sid = _resolve(session_id) or _review_session_id()
-    hole = " ".join(p.get("hero_cards") or []) or None
-    board = " ".join(p.get("board") or []) or None
-    cutoff = (datetime.now(timezone.utc) - timedelta(seconds=window_sec)).isoformat()
-    row = _c().execute(
-        "SELECT id FROM poker_hands WHERE session_id = ? AND at >= ? "
-        "AND hole_cards IS ? AND board IS ? ORDER BY id DESC LIMIT 1",
-        (sid, cutoff, hole, board),
-    ).fetchone()
-    return int(row["id"]) if row else None
-
-
-def _fill_hero_stack(parsed: dict, session_id: int | None) -> dict:
-    """Default hero's starting stack to the last logged stack (current_stack) when the hand
-    didn't state one — the system already knows his stack from the stack log even when he
-    doesn't restate it every hand. Only fills a genuinely missing value; a stack he gave in
-    the hand text always wins. Marks the hero player stack_inferred so it's honest about it."""
-    if not isinstance(parsed, dict) or parsed.get("hero_involved", True) is False:
-        return parsed
-    hero_pos = parsed.get("hero_pos")
-    if not hero_pos:
-        return parsed
-    players = parsed.setdefault("players", [])
-    hero = next((pl for pl in players if pl.get("hero") or pl.get("pos") == hero_pos), None)
-    if hero and hero.get("stack") not in (None, 0):
-        return parsed  # he stated a stack — never override it
-    stack = current_stack(session_id)
-    if stack is None:
-        return parsed  # nothing logged yet to borrow
-    if hero is None:
-        hero = {"pos": hero_pos}
-        players.append(hero)
-    hero["stack"] = stack
-    hero["stack_inferred"] = True
-    return parsed
-
-
 def record_hand(shorthand: str, session_id: int | None = None, stakes: str | None = None,
                 tag: str | None = None, lesson: str | None = None,
                 backend: str | None = None) -> dict:
-    """Parse shorthand -> structured hand -> store. Returns {id, parsed} (id None on parse fail).
+    """Parse shorthand -> structured hand -> store. Returns {id, parsed} (id None on parse fail)."""
-    Idempotent: if this exact hand was just logged for the session (double turn execution),
-    returns the existing one instead of inserting a duplicate. Hero's stack is auto-filled
-    from the last stack log when he didn't restate it."""
     parsed = parse_hand(shorthand, stakes=stakes, backend=backend)
     if not parsed:
         return {"id": None, "parsed": None}
-    parsed = _fill_hero_stack(parsed, session_id)
-    dup = _recent_duplicate_hand(parsed, session_id)
-    if dup is not None:
-        return {"id": dup, "parsed": parsed, "linked": 0, "deduped": True}
     hid = store_hand_history(parsed, session_id=session_id, tag=tag, lesson=lesson)
     linked = link_hand_players(hid, parsed, session_id=session_id)  # enrich villain files
     return {"id": hid, "parsed": parsed, "linked": linked}

lyra/poker_prompts.py

@@ -147,15 +147,6 @@ def classify(user_msg: str, roster_handles=()) -> str:
     return "CHAT"
 
 
-def looks_like_hero_hand(user_msg: str) -> bool:
-    """True when the message is Brian's OWN hand (first-person + real card content) —
-    the guard for force-logging. Deliberately conservative: an observed hand (a villain
-    the actor, no I/me/my) returns False so we never force-log someone else's hand as his."""
-    msg = (user_msg or "").strip()
-    low = msg.lower()
-    return bool(_FIRST_PERSON.search(low)) and _looks_like_hand(low, msg)
-
-
 # --- always-on base (poker) ----------------------------------------------
 
 BASE = """You are copiloting Brian's LIVE cash game — at the table with him, a session open. \
@@ -195,19 +186,14 @@ it's worth it; the log is mandatory, the commentary optional. Do NOT analyze it
 
 _F_HAND = """MESSAGE TYPE: HAND. First: was Brian IN this hand? If he only WATCHED it (no I/me/my \
 holding cards — two other players), it's really observed: log the players' actions as reads / \
-record it as an observed hand, and do NOT analyze it as his. If it's HIS hand → record_hand first. \
+record it as an observed hand, and do NOT analyze it as his. If it's HIS hand → record_hand, \
-Then read the hand off the RECORDED cards, not by eye: name his made hand by the street it mattered \
+then (NLH only) reason about BET INTENT: for each meaningful bet, what was it for (value / bluff \
-(flopped/turned/rivered top pair / set / quads / etc.). At a SHOWDOWN where his and the caller's \
+/ protection) and did it work — a fold to a value bet = value left behind; a call of a bluff = \
-cards are both known, call analyze_spot(hero, villain, full board) to confirm the made hands and \
+it failed. Call analyze_spot for any close equity/who's-ahead spot — never eyeball. Name leaks \
-who won BEFORE you comment — NEVER eyeball a finished board (it also catches impossible cards). Same \
+plainly (owning value, missed value, sizing); give ONE real opinion. NO reflexive praise ("nice \
-for any close equity / who's-ahead / outs spot. (NLH only) reason about BET INTENT: for each \
+hand"). If a named villain is referenced, use their profile/the scouting note — don't invent a \
-meaningful bet, what was it for (value / bluff / protection) and did it work — a fold to a value bet \
+read. PLO/non-NLH: log and replay it, offer at most a light read, do NOT attempt NLH-style \
-= value left behind; a call of a bluff = it failed. Name leaks plainly (owning value, missed value, \
+equity. Prose, not a listicle."""
-sizing) and give ONE real opinion. If there's genuinely no leak (e.g. he flopped the near-nuts and \
-stacked off), SAY so — don't manufacture a takeaway. NO reflexive praise ("nice hand"), NO \
-variance-evens-out / resilience / life-lesson filler, NO cross-hand pep talk. If a named villain is \
-referenced, use their profile/the scouting note — don't invent a read. PLO/non-NLH: log and replay \
-it, offer at most a light read, do NOT attempt NLH-style equity. Prose, not a listicle."""
 
 _F_TABLE = """MESSAGE TYPE: TABLE — roster management. "seat the table: …" → seat_players. A table \
 change ("table broke", "I got moved", "switched tables") → clear_table, then wait for the new \

lyra/web/server.py

@@ -273,13 +273,11 @@ def create_app() -> FastAPI:
         user_msg = _last_user_message(body.get("messages", []))
 
         model_override = body.get("model") or None
-        turn_id = body.get("turnId") 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,
+            reply = await asyncio.to_thread(chat.respond, session_id, user_msg, backend, model_override)
-                                            model_override, turn_id)
         except Exception as exc:
             logbus.log("error", "chat failed", session=session_id, error=str(exc))
             reply = f"[error] {exc}"
@@ -307,7 +305,6 @@ def create_app() -> FastAPI:
         backend = _backend_for(body.get("backend"))
         user_msg = _last_user_message(body.get("messages", []))
         model_override = body.get("model") or None
-        turn_id = body.get("turnId") or None
         memory.ensure_session(session_id)
         if body.get("mode"):
             memory.set_session_mode(session_id, body["mode"])
@@ -319,8 +316,7 @@ def create_app() -> FastAPI:
 
             def produce():
                 try:
-                    for event in chat.respond_stream(session_id, user_msg, backend,
+                    for event in chat.respond_stream(session_id, user_msg, backend, model_override):
-                                                     model_override, turn_id):
                         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))

lyra/web/static/index.html

@@ -398,17 +398,10 @@
       // live poker session forces the cloud backend regardless of the saved pick.
       if (mode === "poker_cash") backend = "cloud";
 
-      // One id per send, carried on BOTH the stream and the blocking fallback so the
-      // server runs this turn exactly once even if you lock your phone and it re-fires.
-      const turnId = (window.crypto && crypto.randomUUID)
-        ? crypto.randomUUID()
-        : String(Date.now()) + "-" + Math.random().toString(36).slice(2);
-
       const body = {
         mode: mode,
         messages: history,
-        sessionId: currentSession,
+        sessionId: currentSession
-        turnId: turnId
       };
 
       // Only add backend if in standard mode

scripts/persona_replay_eval.py

@@ -0,0 +1,34 @@
+"""Replay the exact prompts where Lyra went 'too safe' through the rewritten persona.
+Run: `uv run python scripts/persona_replay_eval.py` (cloud backend; needs OPENAI_API_KEY).
+Pick a backend/model with env vars, e.g. `EVAL_BACKEND=mi50 uv run python …` or
+`EVAL_BACKEND=local EVAL_MODEL=dolphin3:8b uv run python …`.
+Eyeball each reply against the four tics: no menu, no tag-question closer, a side taken."""
+from __future__ import annotations
+
+import os
+
+from lyra import persona, llm
+
+# The real safe-trigger prompts from the diagnosed transcripts.
+PROMPTS = [
+    "I could run the miner ~8 hours a day. In theory that's about $7.30 of Monero a day. Or am I over simplifying?",
+    "Do you want more time between your dream cycles? Or less?",
+    "I sort of just slept all day. Kind of a bummer.",
+    "So the only way to make money with AI is SaaS apps basically?",
+    "I'm not writing any of the code, it's all Claude. I feel like a phony.",
+]
+
+
+def main() -> None:
+    backend = os.getenv("EVAL_BACKEND", "cloud")
+    model = os.getenv("EVAL_MODEL") or None
+    system = persona.core_prompt()
+    print(f"### backend={backend} model={model or '(default)'}")
+    for i, p in enumerate(PROMPTS, 1):
+        msgs = [{"role": "system", "content": system}, {"role": "user", "content": p}]
+        reply = llm.complete(msgs, backend=backend, model=model)
+        print(f"\n{'='*80}\n[{i}] USER: {p}\nLYRA: {reply}\n")
+
+
+if __name__ == "__main__":
+    main()

tests/test_hand_dedup.py

@@ -1,109 +0,0 @@
-"""record_hand idempotency + straddle parse coverage.
-
-The chat turn can execute twice — the SSE stream and the blocking fallback both run
-server-side (two 'chat request' lines, 1s apart) — which double-logged the same hand
-once logging became guaranteed. A system-of-record must record an event once."""
-from __future__ import annotations
-
-import importlib
-
-import pytest
-
-
-@pytest.fixture
-def poker(tmp_path, monkeypatch):
-    monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
-    from lyra import llm
-    monkeypatch.setattr(llm, "embed", lambda texts: [[0.1, 0.2, 0.3] for _ in texts])
-    import lyra.memory as memory
-    importlib.reload(memory)
-    import lyra.poker as poker
-    importlib.reload(poker)
-    return poker
-
-
-_PARSED = {
-    "game": "NLH", "hero_pos": "SB", "hero_cards": ["Ah", "Kh"],
-    "board": ["Kd", "9d", "4c", "2s"], "players": [], "actions": [],
-    "result": {"hero_net": -200, "pot": 400},
-}
-
-
-def test_record_hand_is_idempotent_across_double_execution(poker, monkeypatch):
-    sid = poker.start_session(venue="Borgata", stakes="1/3", buy_in=400)
-    monkeypatch.setattr(poker, "parse_hand", lambda *a, **k: dict(_PARSED))
-    first = poker.record_hand("i have AhKh in the SB, btn straddle, ...")
-    second = poker.record_hand("i have AhKh in the SB, btn straddle, ...")   # the duplicate turn
-    assert first["id"] == second["id"]
-    assert second.get("deduped") is True
-    assert len(poker.list_hands(sid)) == 1          # ledger holds ONE, not two
-
-
-def test_record_hand_does_not_dedupe_a_genuinely_different_hand(poker, monkeypatch):
-    sid = poker.start_session(venue="Borgata", stakes="1/3", buy_in=400)
-    monkeypatch.setattr(poker, "parse_hand", lambda *a, **k: dict(_PARSED))
-    poker.record_hand("hand one")
-    other = dict(_PARSED, hero_cards=["Qs", "Qd"], board=["Qh", "7c", "2s"])
-    monkeypatch.setattr(poker, "parse_hand", lambda *a, **k: dict(other))
-    poker.record_hand("a different hand entirely")
-    assert len(poker.list_hands(sid)) == 2          # distinct hands both land
-
-
-def test_dedupe_handles_boardless_hand(poker, monkeypatch):
-    # NULL-safe match: a preflop-only hand (no board) still dedupes.
-    sid = poker.start_session(venue="Borgata", buy_in=400)
-    preflop = {"game": "NLH", "hero_pos": "BTN", "hero_cards": ["As", "Ks"],
-               "board": [], "players": [], "actions": [], "result": {"hero_net": 30}}
-    monkeypatch.setattr(poker, "parse_hand", lambda *a, **k: dict(preflop))
-    a = poker.record_hand("AKs btn, i open everyone folds")
-    b = poker.record_hand("AKs btn, i open everyone folds")
-    assert a["id"] == b["id"] and len(poker.list_hands(sid)) == 1
-
-
-def test_parse_prompt_records_straddles():
-    from lyra import poker as pk
-    p = pk._HAND_PARSE_PROMPT.lower()
-    assert "straddle" in p and "button straddle" in p
-    assert "acts last preflop" in p or "act last preflop" in p
-
-
-# --- hero stack auto-fill from the last logged stack ----------------------
-
-def test_hero_stack_filled_from_last_stack_log(poker, monkeypatch):
-    poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
-    poker.log_stack(275)                                   # his last reported stack
-    monkeypatch.setattr(poker, "parse_hand",
-                        lambda *a, **k: {"game": "NLH", "hero_involved": True,
-                                         "hero_pos": "CO", "hero_cards": ["As", "Ks"],
-                                         "board": ["2c"], "players": [], "actions": [],
-                                         "result": {"hero_net": 50}})
-    out = poker.record_hand("AKs in the CO, i raise, flop 2c...")
-    stored = poker.get_hand(out["id"])["structured"]
-    hero = next(pl for pl in stored["players"] if pl.get("hero"))
-    assert hero["stack"] == 275 and hero.get("stack_inferred") is True
-
-
-def test_stated_stack_is_never_overridden(poker, monkeypatch):
-    poker.start_session(venue="Meadows", buy_in=400)
-    poker.log_stack(275)
-    monkeypatch.setattr(poker, "parse_hand",
-                        lambda *a, **k: {"game": "NLH", "hero_involved": True,
-                                         "hero_pos": "BTN", "hero_cards": ["Qh", "Qd"],
-                                         "players": [{"pos": "BTN", "stack": 500}],
-                                         "board": [], "actions": [], "result": {}})
-    out = poker.record_hand("500 deep on the btn with QQ")
-    hero = next(pl for pl in poker.get_hand(out["id"])["structured"]["players"]
-                if pl.get("pos") == "BTN")
-    assert hero["stack"] == 500 and not hero.get("stack_inferred")
-
-
-def test_observed_hand_gets_no_hero_stack(poker, monkeypatch):
-    poker.start_session(venue="Meadows", buy_in=400)
-    poker.log_stack(275)
-    monkeypatch.setattr(poker, "parse_hand",
-                        lambda *a, **k: {"game": "NLH", "hero_involved": False,
-                                         "hero_pos": None, "hero_cards": [],
-                                         "players": [{"pos": "CO", "cards": ["Kx", "Kx"]}],
-                                         "board": [], "actions": [], "result": {}})
-    out = poker.record_hand("the CO stacked off KK vs the nit")
-    assert all(not pl.get("stack_inferred") for pl in poker.get_hand(out["id"])["structured"]["players"])

tests/test_hand_logging.py

@@ -1,97 +0,0 @@
-"""Reliable hand logging: hero-hand guard, tool-visible history (B), forced log (A).
-
-Root cause these guard: mid-session, memory.history() rebuilt past turns as
-'hand -> narration' with tool calls stripped, few-shot-conditioning the model to
-stop logging (clean history logged 4/4, the stripped history 0/4)."""
-from __future__ import annotations
-
-from types import SimpleNamespace
-
-from lyra import poker_prompts as pp
-
-
-# --- the hero-hand guard (who gets force-logged) --------------------------
-
-def test_looks_like_hero_hand_true_for_brians_own_hand():
-    assert pp.looks_like_hero_hand("im utg with 2d2s. i raise to $15, btn calls")
-    assert pp.looks_like_hero_hand("300eff. i call btn w AsQs, flop Qh7c2s, i bet 20 he calls")
-
-
-def test_looks_like_hero_hand_false_for_observed_and_chatter():
-    # A villain the actor (no I/me/my) must never be force-logged as Brian's hand.
-    assert not pp.looks_like_hero_hand("TAG limped A4o in the SB")
-    assert not pp.looks_like_hero_hand("how's the table looking tonight?")
-    assert not pp.looks_like_hero_hand("")
-
-
-# --- Fix B: tool calls made visible in reconstructed history --------------
-
-def _ex(role, content, at):
-    return SimpleNamespace(role=role, content=content, created_at=at, id=hash(at))
-
-
-def test_history_marks_the_assistant_turn_that_logged(monkeypatch):
-    from lyra import mind, memory
-    recent = [
-        _ex("user", "i have 2d2s utg, flop 2c2hKs, quads", "2026-07-10T18:00:00.000000+00:00"),
-        _ex("assistant", "Sick cooler.", "2026-07-10T18:00:05.000000+00:00"),
-        _ex("user", "how am i doing", "2026-07-10T18:01:00.000000+00:00"),
-        _ex("assistant", "Up a grand.", "2026-07-10T18:01:03.000000+00:00"),
-    ]
-    monkeypatch.setattr(memory, "tool_events", lambda sid: [
-        {"tool": "record_hand", "result": "Hand #62 logged — UTG 2d2s.",
-         "created_at": "2026-07-10T18:00:03.000000+00:00"},
-        {"tool": "session_state", "result": "net +1000",
-         "created_at": "2026-07-10T18:01:02.000000+00:00"},
-    ])
-    msgs = mind._history_with_tools("s1", recent)
-    # each event is attributed to the assistant turn whose window it falls in
-    assert "record_hand → Hand #62 logged" in msgs[1]["content"]
-    assert msgs[1]["content"].endswith("Sick cooler.")
-    assert "session_state" in msgs[3]["content"]
-    # user turns are untouched
-    assert msgs[0]["content"] == recent[0].content
-
-
-def test_history_no_marker_when_no_tools(monkeypatch):
-    from lyra import mind, memory
-    monkeypatch.setattr(memory, "tool_events", lambda sid: [])
-    recent = [_ex("assistant", "just talking", "2026-07-10T18:00:05.000000+00:00")]
-    assert mind._history_with_tools("s1", recent)[0]["content"] == "just talking"
-
-
-# --- Fix A: force the log when the model skipped a hero hand ---------------
-
-def _force_setup(monkeypatch, tool_calls):
-    from lyra import chat
-    monkeypatch.setattr(chat.llm, "chat_call",
-                        lambda *a, **k: ({"role": "assistant"}, tool_calls))
-    dispatched = []
-    monkeypatch.setattr(chat.toolkit, "dispatch",
-                        lambda name, args, ctx=None: dispatched.append(name) or "Hand #71 logged.")
-    monkeypatch.setattr(chat.memory, "add_tool_event", lambda *a, **k: 1)
-    return chat, dispatched
-
-
-def test_forces_log_on_unlogged_hero_hand(monkeypatch):
-    chat, dispatched = _force_setup(monkeypatch, [{"id": "1", "name": "record_hand",
-                                                   "arguments": '{"shorthand":"AsQs..."}'}])
-    forced = chat._ensure_hand_logged([], "300eff i call btn w AsQs, i bet 20", "HAND", [],
-                                      "cloud", None, {}, "s1")
-    assert forced == ["record_hand"] and dispatched == ["record_hand"]
-
-
-def test_does_not_force_when_already_logged(monkeypatch):
-    chat, dispatched = _force_setup(monkeypatch, [])
-    forced = chat._ensure_hand_logged([], "i have AsQs, i bet", "HAND", ["record_hand"],
-                                      "cloud", None, {}, "s1")
-    assert forced == [] and dispatched == []
-
-
-def test_does_not_force_non_hand_or_observed(monkeypatch):
-    chat, dispatched = _force_setup(monkeypatch, [])
-    # not a HAND turn
-    assert chat._ensure_hand_logged([], "down to 220", "LOG", [], "cloud", None, {}, "s1") == []
-    # HAND-classified but observed (no first person) → never force-logged as his
-    assert chat._ensure_hand_logged([], "TAG shoved AKo", "HAND", [], "cloud", None, {}, "s1") == []
-    assert dispatched == []

tests/test_persona.py

@@ -0,0 +1,49 @@
+"""Persona composition + voice guards. Run via `uv run pytest` FROM the worktree."""
+from __future__ import annotations
+
+from lyra import persona
+
+# core_prompt() char length on the pre-rewrite persona (measured 2026-07-08).
+# The rewrite must not bloat the always-on hot path past this.
+BASELINE_CORE_CHARS = 2878
+
+
+def _core() -> str:
+    persona._sections.cache_clear()  # file changed on disk since import
+    return persona.core_prompt()
+
+
+def test_right_now_is_not_in_the_always_on_core():
+    # Demoted out of _CORE: its content must no longer ride every turn.
+    assert "Right now" not in persona._CORE
+    assert "are coming" not in _core()            # the stale promise is gone from core
+    assert "player content library" not in _core()
+
+
+def test_right_now_section_still_exists_and_is_accurate():
+    rn = persona.section("Right now")
+    assert rn                                       # still a loadable situational section
+    assert "are coming" not in rn                   # stats/profiling are SHIPPED — no stale promise
+    assert "analyze_spot" in rn                     # names a real, current capability
+
+
+def test_how_you_talk_carries_the_anti_tic_rules():
+    core = _core().lower()
+    # The four tics, each named as a rule (anchor phrases from the rewrite):
+    assert "commit" in core                          # menu-instead-of-pick
+    assert "hand the verdict back" in core           # tag-question deferral
+    assert "don't reach for the instant silver lining" in core  # reassurance reflex
+    assert "disagree when you disagree" in core       # both-sides-ing / no-friction
+
+
+def test_how_you_talk_has_real_exemplars_not_just_traits():
+    core = _core()
+    # Lifted from her own best moments — concrete voice, not labels:
+    assert "type every semicolon" in core            # imposter-syndrome exemplar
+    assert "hold off on the cash game" in core        # fatigue/EV judgment exemplar
+
+
+def test_old_hedgy_trait_bullet_is_gone():
+    core = _core()
+    # the vague trait line the model nodded at and ignored
+    assert "you could consider folding" not in core

tests/test_poker_prompts.py

@@ -114,24 +114,3 @@ def test_hardening_log_needs_number_or_result_word():
     assert c("rebought for 300") == "LOG"
     # first-person departure is Brian, not a roster op → not TABLE
     assert c("I busted, heading home") != "TABLE"
-
-
-# --- HAND fragment: route showdowns to the tool + no motivational mush ---
-
-def test_hand_fragment_routes_showdowns_to_the_tool():
-    # A resolved showdown must be verified via analyze_spot, not eyeballed
-    # (the quad-kings-read-as-"kings-full" regression).
-    frag = pp.fragment_for("HAND")
-    assert "SHOWDOWN" in frag
-    assert "analyze_spot" in frag
-    assert "never eyeball" in frag.lower()
-    # names the hand class by street so "flopped quads" actually gets said
-    assert "street it mattered" in frag
-
-
-def test_hand_fragment_bans_motivational_filler():
-    frag = pp.fragment_for("HAND")
-    assert "variance-evens-out" in frag
-    assert "life-lesson" in frag
-    # if there's no leak, say so instead of inventing a takeaway
-    assert "no leak" in frag.lower()

tests/test_turn_dedup.py

@@ -1,93 +0,0 @@
-"""Turn de-duplication: the UI hits two endpoints for one message (SSE stream +
-blocking fallback). Only the first should execute; the duplicate reuses its result."""
-from __future__ import annotations
-
-import pytest
-
-from lyra import chat
-
-
-@pytest.fixture(autouse=True)
-def _clean_turns():
-    chat._turns.clear()
-    yield
-    chat._turns.clear()
-
-
-def test_claim_is_owner_once_per_key():
-    o1, r1 = chat._claim_turn("s1", "flopped a set")
-    o2, r2 = chat._claim_turn("s1", "flopped a set")
-    assert o1 is True and o2 is False
-    assert r1 is r2                       # the duplicate waits on the SAME record
-
-
-def test_different_messages_each_own():
-    o1, _ = chat._claim_turn("s1", "hand A")
-    o2, _ = chat._claim_turn("s1", "hand B")
-    o3, _ = chat._claim_turn("s2", "hand A")     # different session
-    assert o1 and o2 and o3
-
-
-def test_await_returns_owner_reply():
-    _, rec = chat._claim_turn("s1", "msg")
-    chat._finish_turn(rec, "the answer")
-    assert chat._await_duplicate(rec) == "the answer"
-
-
-def test_respond_duplicate_reuses_result_without_running_turn(monkeypatch):
-    # owner already ran and cached its reply
-    _, rec = chat._claim_turn("s1", "same hand")
-    chat._finish_turn(rec, "owner reply")
-
-    def boom(*a, **k):
-        raise AssertionError("duplicate must NOT execute the turn")
-    monkeypatch.setattr(chat.mind, "assemble", boom)
-
-    out = chat.respond("s1", "same hand", "cloud")
-    assert out == "owner reply"
-
-
-def test_respond_stream_duplicate_yields_cached_reply(monkeypatch):
-    _, rec = chat._claim_turn("s1", "same hand")
-    chat._finish_turn(rec, "owner reply")
-
-    def boom(*a, **k):
-        raise AssertionError("duplicate must NOT execute the turn")
-    monkeypatch.setattr(chat.mind, "assemble", boom)
-
-    events = list(chat.respond_stream("s1", "same hand", "cloud"))
-    assert ("delta", "owner reply") in events
-    assert ("done", "owner reply") in events
-
-
-def test_fresh_message_after_window_runs_again():
-    # a completed turn lingers only briefly; simulate expiry and confirm re-ownership
-    o1, rec = chat._claim_turn("s1", "later resend")
-    chat._finish_turn(rec, "first")
-    rec["ts"] -= chat._TURN_TTL_MSG + 1       # age it past the (session,msg) window
-    o2, _ = chat._claim_turn("s1", "later resend")
-    assert o1 and o2                          # a genuine later resend runs fresh
-
-
-# --- client turn-id keying (the fire-and-forget guarantee) ----------------
-
-def test_same_turn_id_dedupes_regardless_of_message():
-    # the fallback may resend the SAME id; dedupe on the id, not the text
-    o1, r1 = chat._claim_turn("s1", "a hand", turn_id="tid-123")
-    o2, r2 = chat._claim_turn("s1", "a hand", turn_id="tid-123")
-    assert o1 is True and o2 is False and r1 is r2
-
-
-def test_different_turn_ids_each_own():
-    o1, _ = chat._claim_turn("s1", "same text", turn_id="tid-1")
-    o2, _ = chat._claim_turn("s1", "same text", turn_id="tid-2")
-    assert o1 and o2                          # a genuinely new send never gets swallowed
-
-
-def test_turn_id_window_survives_long_after_the_msg_window():
-    # locked-phone case: the re-fire can arrive minutes later and must still dedupe
-    o1, rec = chat._claim_turn("s1", "big hand", turn_id="tid-lock")
-    chat._finish_turn(rec, "cached")
-    rec["ts"] -= chat._TURN_TTL_MSG + 60      # well past the short window, but not the id window
-    o2, r2 = chat._claim_turn("s1", "big hand", turn_id="tid-lock")
-    assert o1 and o2 is False and r2["reply"] == "cached"