Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 serversdown
|
fc623db27a |
@@ -1,54 +0,0 @@
|
||||
# MI50 runaway watchdog (fallback layer "A")
|
||||
|
||||
Independent host-side backstop to Lyra's in-app dream-cycle budget (layer "C",
|
||||
`lyra/dream.py`). Stops the llama.cpp backend if the MI50 is busy too long or too
|
||||
hot, and pings Brian. See
|
||||
`docs/superpowers/specs/2026-07-04-mi50-runaway-guards-design.md`.
|
||||
|
||||
## What it does
|
||||
|
||||
Runs on the **Proxmox host** (`10.0.0.4`) via a systemd timer, every ~2 min:
|
||||
|
||||
- **Duration:** if the GPU is busy (`rocm-smi` use% > 0) for **3600s continuously**,
|
||||
it stops the container. Any idle read resets the streak, so a legitimate ~40-min
|
||||
manual workload never trips it.
|
||||
- **Temperature:** if junction ≥ **97°C** for **3 consecutive checks (~6 min)**, it
|
||||
stops the container — independent of duration.
|
||||
- On either trip: `pct exec 202 -- docker stop lyra-brain`, clear state, `logger` a
|
||||
line, and POST to your ntfy topic.
|
||||
|
||||
All thresholds are `Environment=` overrides in the `.service`.
|
||||
|
||||
## Install (on the Proxmox host, as root)
|
||||
|
||||
```sh
|
||||
# copy the three files up (from the repo, on lyra-cortex):
|
||||
scp -i ~/.ssh/id_lyra_proxmox deploy/mi50-watchdog/mi50-watchdog.sh \
|
||||
root@10.0.0.4:/usr/local/sbin/mi50-watchdog.sh
|
||||
scp -i ~/.ssh/id_lyra_proxmox deploy/mi50-watchdog/mi50-watchdog.{service,timer} \
|
||||
root@10.0.0.4:/etc/systemd/system/
|
||||
|
||||
# on the host:
|
||||
chmod +x /usr/local/sbin/mi50-watchdog.sh
|
||||
# set your ntfy topic (same one Lyra uses) in the service:
|
||||
sed -i 's/CHANGE_ME/YOUR_NTFY_TOPIC/' /etc/systemd/system/mi50-watchdog.service
|
||||
systemctl daemon-reload
|
||||
systemctl enable --now mi50-watchdog.timer
|
||||
```
|
||||
|
||||
## Verify (when the card is back and healthy)
|
||||
|
||||
```sh
|
||||
# dry run once, watch what it decides:
|
||||
NTFY_URL= /usr/local/sbin/mi50-watchdog.sh; echo "exit $?"
|
||||
journalctl -t mi50-watchdog -n 20 --no-pager
|
||||
|
||||
# force a trip test with tiny thresholds (won't touch a healthy idle card unless busy):
|
||||
MAX_BUSY_SEC=60 TEMP_KILL_C=40 TEMP_KILL_STREAK=1 /usr/local/sbin/mi50-watchdog.sh
|
||||
# confirm it stopped lyra-brain + sent the ntfy, then restart the container.
|
||||
|
||||
systemctl list-timers mi50-watchdog.timer # confirm it's scheduled
|
||||
```
|
||||
|
||||
**Not yet installed / live-verified** — staged here on 2026-07-04 while the card is
|
||||
off and Brian is away. Install + trip-test when the MI50 is back.
|
||||
@@ -1,16 +0,0 @@
|
||||
[Unit]
|
||||
Description=MI50 runaway watchdog (stop the llama.cpp backend if the GPU is busy too long or too hot)
|
||||
After=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
# Fill in your ntfy topic so it can ping Brian when it trips (leave URL empty to log only).
|
||||
Environment=NTFY_URL=https://ntfy.sh
|
||||
Environment=NTFY_TOPIC=CHANGE_ME
|
||||
# Optional overrides (defaults shown):
|
||||
# Environment=MAX_BUSY_SEC=3600
|
||||
# Environment=TEMP_KILL_C=97
|
||||
# Environment=TEMP_KILL_STREAK=3
|
||||
# Environment=CTID=202
|
||||
# Environment=CONTAINER=lyra-brain
|
||||
ExecStart=/usr/local/sbin/mi50-watchdog.sh
|
||||
@@ -1,82 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# MI50 runaway watchdog — fallback layer "A".
|
||||
#
|
||||
# Runs on the Proxmox HOST (10.0.0.4) via a systemd timer (every ~2 min). It is the
|
||||
# independent backstop to Lyra's own in-app dream-cycle budget ("C", in lyra/dream.py):
|
||||
# if the MI50 is busy too LONG or runs too HOT, it stops the llama.cpp backend and
|
||||
# pings Brian — regardless of what caused it. Trips on duration only after a full hour
|
||||
# of *continuous* busy, so a legitimate ~40-min manual workload runs untouched.
|
||||
#
|
||||
# The GPU lives on the host; the llama.cpp container ("lyra-brain") runs inside LXC
|
||||
# CT202. So temp/use come from host rocm-smi, and the stop goes via `pct exec`.
|
||||
#
|
||||
# See docs/superpowers/specs/2026-07-04-mi50-runaway-guards-design.md
|
||||
set -uo pipefail
|
||||
|
||||
# --- tunables (override in the .service via Environment=) ---
|
||||
CTID="${CTID:-202}" # LXC holding the docker container
|
||||
CONTAINER="${CONTAINER:-lyra-brain}"
|
||||
MAX_BUSY_SEC="${MAX_BUSY_SEC:-3600}" # 1 hr continuous busy -> stop
|
||||
TEMP_KILL_C="${TEMP_KILL_C:-97}" # junction >= this ...
|
||||
TEMP_KILL_STREAK="${TEMP_KILL_STREAK:-3}" # ... for this many consecutive checks (~6 min)
|
||||
NTFY_URL="${NTFY_URL:-}" # e.g. https://ntfy.sh (empty => log only)
|
||||
NTFY_TOPIC="${NTFY_TOPIC:-}"
|
||||
BUSY_STATE="${BUSY_STATE:-/run/mi50-watchdog.busy_since}"
|
||||
HOT_STATE="${HOT_STATE:-/run/mi50-watchdog.hot_streak}"
|
||||
|
||||
now="$(date +%s)"
|
||||
|
||||
alert() { # $1 title, $2 message
|
||||
logger -t mi50-watchdog "$2"
|
||||
if [[ -n "$NTFY_URL" && -n "$NTFY_TOPIC" ]]; then
|
||||
curl -s -m 8 -H "Title: $1" -H "Priority: urgent" -H "Tags: warning" \
|
||||
-d "$2" "$NTFY_URL/$NTFY_TOPIC" >/dev/null 2>&1 || true
|
||||
fi
|
||||
}
|
||||
|
||||
stop_backend() { # $1 reason
|
||||
pct exec "$CTID" -- docker stop "$CONTAINER" >/dev/null 2>&1 || true
|
||||
rm -f "$BUSY_STATE" "$HOT_STATE"
|
||||
alert "MI50 watchdog stopped the card" "$1"
|
||||
}
|
||||
|
||||
# Nothing to guard if the backend isn't even running.
|
||||
running="$(pct exec "$CTID" -- docker inspect -f '{{.State.Running}}' "$CONTAINER" 2>/dev/null || echo false)"
|
||||
if [[ "$running" != "true" ]]; then
|
||||
rm -f "$BUSY_STATE" "$HOT_STATE"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
use="$(rocm-smi --showuse 2>/dev/null | awk -F: '/GPU use \(%\)/ {gsub(/[^0-9]/, "", $NF); print $NF; exit}')"
|
||||
junction="$(rocm-smi --showtemp 2>/dev/null | awk -F: '/junction/ {gsub(/[^0-9.]/, "", $NF); print $NF; exit}')"
|
||||
|
||||
# --- duration rule: accumulate continuous busy time in a state file ---
|
||||
busy=0
|
||||
[[ "${use:-}" =~ ^[0-9]+$ ]] && (( use > 0 )) && busy=1
|
||||
if (( busy )); then
|
||||
[[ -f "$BUSY_STATE" ]] || echo "$now" > "$BUSY_STATE"
|
||||
since="$(cat "$BUSY_STATE" 2>/dev/null || echo "$now")"
|
||||
elapsed=$(( now - since ))
|
||||
if (( elapsed >= MAX_BUSY_SEC )); then
|
||||
stop_backend "MI50 busy ${elapsed}s continuously (>= ${MAX_BUSY_SEC}s) — stopped ${CONTAINER}."
|
||||
exit 0
|
||||
fi
|
||||
else
|
||||
rm -f "$BUSY_STATE" # idle breaks the streak
|
||||
fi
|
||||
|
||||
# --- temperature rule: independent of duration ---
|
||||
if [[ "${junction:-}" =~ ^[0-9.]+$ ]]; then
|
||||
jint="${junction%.*}"
|
||||
if (( jint >= TEMP_KILL_C )); then
|
||||
streak=$(( $(cat "$HOT_STATE" 2>/dev/null || echo 0) + 1 ))
|
||||
echo "$streak" > "$HOT_STATE"
|
||||
if (( streak >= TEMP_KILL_STREAK )); then
|
||||
stop_backend "MI50 junction ${jint}C >= ${TEMP_KILL_C}C for ${streak} checks — stopped ${CONTAINER}."
|
||||
exit 0
|
||||
fi
|
||||
else
|
||||
rm -f "$HOT_STATE" # cooled off, reset the streak
|
||||
fi
|
||||
fi
|
||||
exit 0
|
||||
@@ -1,10 +0,0 @@
|
||||
[Unit]
|
||||
Description=Run the MI50 runaway watchdog every 2 minutes
|
||||
|
||||
[Timer]
|
||||
OnBootSec=2min
|
||||
OnUnitActiveSec=2min
|
||||
AccuracySec=15s
|
||||
|
||||
[Install]
|
||||
WantedBy=timers.target
|
||||
@@ -0,0 +1,48 @@
|
||||
# Decision log — Decide mode's learning layer
|
||||
|
||||
Built overnight on `feat/decision-log`. This is the **data layer + tools only**. The
|
||||
prompt/mode wiring (the taste part) is left for you on purpose — no persona/card edits
|
||||
were made.
|
||||
|
||||
## The idea
|
||||
|
||||
Decide mode is currently a one-shot tie-breaker. The learning layer gives it memory:
|
||||
log the call Brian actually makes, record how it turned out, and recall similar past
|
||||
calls so a new recommendation leans on his own track record instead of generic advice.
|
||||
|
||||
Lifecycle: **log** (when the call is made) → **resolve** (later, with the outcome) →
|
||||
**recall** (next time something similar comes up).
|
||||
|
||||
## What's built
|
||||
|
||||
**Storage** (`lyra/memory.py`):
|
||||
- `decisions` table — situation, options, choice, rationale, confidence (1-5), tags,
|
||||
embedding (over situation+choice), outcome, outcome_rating (-1/0/+1), resolved_at.
|
||||
- `Decision` dataclass (with a `.resolved` property).
|
||||
- `log_decision(...) -> id`, `resolve_decision(id, outcome, rating) -> bool`,
|
||||
`get_decision(id)`, `list_decisions(limit, open_only)`,
|
||||
`recall_decisions(query, k)` (cosine over embeddings, each hit carries `.score`).
|
||||
- Embedding failures never block a log (blob just stays NULL).
|
||||
|
||||
**Tools** (`lyra/tools.py`) — handlers + specs, wired into `dispatch`:
|
||||
- `log_decision` (situation, choice, options?, rationale?, confidence?, tags?)
|
||||
- `resolve_decision` (decision_id, outcome, rating?)
|
||||
- `recall_decisions` (query, k?) — returns past calls with their verdicts
|
||||
|
||||
**Tests** (`tests/test_decisions.py`) — 9, covering roundtrip, resolve, open-only
|
||||
filtering, similarity ranking, and all three tool handlers. Full suite green, ruff clean.
|
||||
|
||||
## What's left for you (the wiring)
|
||||
|
||||
1. **Allow-list** — add the three tools to `_DECIDE_TOOLS` in `lyra/modes.py`
|
||||
(and decide whether `recall_decisions` also belongs in Study). One-liner, but it's
|
||||
the gate that lets her actually call them.
|
||||
2. **Decide card guidance** — tell her *when* to use them: recall similar decisions
|
||||
before recommending, log once Brian commits to a call, and circle back to resolve
|
||||
open ones. This is the part I didn't want to touch without you (no bandaids).
|
||||
3. **Optional surfacing** — open/unresolved decisions are a natural thing for her to
|
||||
raise (thought loop / ping), and a small UI panel could list them. Not built.
|
||||
4. **Optional auto-prompt to resolve** — the dream loop could notice decisions that
|
||||
have been open a while and nudge for an outcome.
|
||||
|
||||
Nothing here changes behavior until step 1 — the tools exist but no mode offers them.
|
||||
@@ -1,72 +0,0 @@
|
||||
# Hand-history contract (Lyra → RTO)
|
||||
|
||||
The canonical structured shape for a poker hand. **Lyra owns hands** — it produces this
|
||||
shape (LLM parser today; the tap recorder natively, going forward), stores it, replays it
|
||||
in the viewer, and exports it. **RTO consumes it** over HTTP and never reaches into Lyra.
|
||||
|
||||
Ownership rule: whoever owns the data owns the tools that produce it. Lyra owns the hand
|
||||
DB, the viewer, and the copilot loop, so hand capture lives here. RTO is a pure engine.
|
||||
|
||||
Coupling: **one arrow, Lyra → RTO, HTTP only.** RTO is a standalone service (solve /
|
||||
exploit / estimate); Lyra POSTs to it when it wants analysis. No shared package, no shared
|
||||
DB, no shared UI components. If RTO is down, Lyra skips analysis and nothing breaks.
|
||||
|
||||
## Schema (`schema_version: 1`)
|
||||
|
||||
```jsonc
|
||||
{
|
||||
"schema_version": 1,
|
||||
"game": "NLH", // NLH | PLO | ...
|
||||
"stakes": "1/3", // or null
|
||||
"hero_pos": "BTN", // one of POSITIONS
|
||||
"hero_cards": ["Ah", "Kh"], // convenience mirror of the hero's players[].cards
|
||||
"players": [ // every player in the hand, incl. hero
|
||||
{"pos": "BTN", "stack": 300, "name": "Hero", "cards": ["Ah","Kh"], "hero": true},
|
||||
{"pos": "BB", "stack": 250, "name": "Sal", "cards": null} // cards: null unless shown
|
||||
],
|
||||
"actions": [ // one flat chronological list across all streets
|
||||
{"street": "preflop", "pos": "BTN", "action": "raise", "amount": 15},
|
||||
{"street": "flop", "board": ["7d","2c","5h"]}, // a street begins with its board reveal
|
||||
{"street": "flop", "pos": "BB", "action": "check"}
|
||||
],
|
||||
"board": ["7d","2c","5h"], // full final board, 0–5 cards
|
||||
"result": {"pot": 40, "hero_net": 25, "summary": "one line"},
|
||||
"completeness": {"cards": true, "board": true, "actions": true}
|
||||
}
|
||||
```
|
||||
|
||||
### Conventions (load-bearing)
|
||||
|
||||
- **Cards are lists of 2-char tokens**, `RankSuit`: rank in `23456789TJQKA` (ten = `T`),
|
||||
suit in `c d h s` (lowercase). E.g. `["As","5d","2c"]`. RTO maps each token via
|
||||
`pokercore.parse_card`. *(Chosen over space-joined strings: unambiguous, no re-splitting,
|
||||
and it's what Lyra already stores + what the viewer reads.)*
|
||||
- **Unknown cards are kept, not dropped:** `"Ax"` = known rank / unknown suit, `"x"` =
|
||||
fully unknown card. The LLM parser emits these when Brian didn't state suits. The tap
|
||||
recorder won't — it captures complete cards by construction — so `"x"` is an
|
||||
import/parser-only concern.
|
||||
- **`completeness`** tells a consumer what's safe to use: `cards`/`board` are `true` only
|
||||
when every relevant card is fully specified (no `"x"`). RTO uses `false`-card hands for
|
||||
positions/frequencies/pairs and skips suit-dependent math (flushes).
|
||||
- **Hero appears in `players[]`** with `"hero": true` and is findable via `pos == hero_pos`.
|
||||
`hero_cards` is a mirror for the viewer; `players[].cards` is the source of truth.
|
||||
- **Positions:** `UTG UTG1 UTG2 MP LJ HJ CO BTN SB BB`.
|
||||
- **Actions:** `post fold check call bet raise allin`. `amount` is a plain number (no `$`),
|
||||
null for non-sized actions (fold/check). Street boards appear as `{street, board}` entries.
|
||||
- **Streets:** `preflop flop turn river`.
|
||||
|
||||
`lyra/poker.py:normalize_structured()` is the single function that guarantees this shape.
|
||||
It runs on store and on read, and is idempotent.
|
||||
|
||||
## Transport (HTTP, Lyra serves on :7078)
|
||||
|
||||
- `GET /hands/data?limit=N` → `{ "hands": [ {id, position, hole_cards, board, result, tag,
|
||||
at, lesson, venue, stakes, has_structured}, ... ] }` — flat list for browsing. Use
|
||||
`has_structured` to pick which hands have a replayable body worth fetching.
|
||||
- `GET /hand/{id}/data` → the full hand row; `structured` is the object above (or `null`
|
||||
for a flat quick-log that hasn't been reconstructed).
|
||||
|
||||
RTO's "Lyra bridge" (its `docs/estimator-design.md`, Phase B) walks `structured.actions`
|
||||
to classify each villain decision into `checked_to` / `facing_bet` / `facing_raise`, and
|
||||
uses shown `cards` + that street's `board` for board-relative categories. Everything that
|
||||
walk needs is in the schema above.
|
||||
@@ -1,167 +0,0 @@
|
||||
# The Scouting Desk — proactive poker recall + villain identity resolution
|
||||
|
||||
*Design spec. Not built yet. Companion to the "she remembers" north star in the
|
||||
`poker-copilot` memory. Written 2026-07-03, before the trial-by-fire session.*
|
||||
|
||||
## Purpose
|
||||
|
||||
Turn the copilot from a logbook into a copilot that **remembers across sessions,
|
||||
unprompted** — the way a broadcast stats desk slides a note to the color
|
||||
commentator: *"he mentioned the guy's hot streak → here are his last 10 games."*
|
||||
|
||||
Target moments:
|
||||
- *"you had this exact leak last week too, remember?"*
|
||||
- *"neck-tattoo guy just 3-bet you — last time he did that at the Meadows he had it."*
|
||||
- *"Sleepy John was here two weeks ago; you stacked off AK into his set."*
|
||||
|
||||
The failure mode to avoid at all costs: **confident-but-wrong.** A stats desk that
|
||||
guesses gets the commentator burned on air. **Silence is the default; the desk
|
||||
speaks only when there's real signal.**
|
||||
|
||||
## What already exists (don't rebuild it)
|
||||
|
||||
`mind.build_messages()` already runs a recall pass on **every** message:
|
||||
`memory.recall(user_msg)` over past exchanges + `memory.recall_summaries(user_msg)`
|
||||
over session gists, injected as system notes before she replies. The
|
||||
"slide-a-note-in-before-she-speaks" machinery is already the architecture. This
|
||||
spec **adds a poker desk** to that pass — it does not build a new RAG system.
|
||||
|
||||
Episodic links also already exist: `link_hand_players` writes a
|
||||
`player_observations` row per named villain in a recorded hand, carrying
|
||||
`hand_id` AND `session_id`; `player_reads` carry `session_id`. So villain →
|
||||
observation → hand → session/date is reconstructable today.
|
||||
|
||||
## Two retrieval channels (don't conflate them)
|
||||
|
||||
1. **Entity desk — deterministic.** A known **name** in the message → exact/fuzzy
|
||||
SQL match on `poker_players` → pull dossier + your history vs him. ~1ms, no
|
||||
hallucination. This is the "hears the name, pulls last 10 games" case.
|
||||
2. **Pattern desk — semantic.** No entity to key on ("I keep punting these river
|
||||
bluffs") → embed the message, retrieve similar **scar notes / hands / recap
|
||||
passages** by meaning. This is where embeddings earn their keep. Also the
|
||||
backbone of nameless-villain matching (below).
|
||||
|
||||
Both feed one injected **STATS DESK** system note, relevance-gated.
|
||||
|
||||
## The hard part: nameless villains
|
||||
|
||||
Most live villains have no name. Brian identifies them by **physical descriptor**
|
||||
("guy with the lips/neck tattoo"), by **seat** ("seat 4", "two to my left"), or —
|
||||
uselessly — **generically** ("mid-aged white dude with glasses").
|
||||
|
||||
### Current gap
|
||||
`poker_players.name` is `NOT NULL` and identity is an **exact name match**
|
||||
(`upsert_player` → `WHERE name = ?`). The `description` column exists but is dead
|
||||
weight: not a key, not embedded, never matched. **Nameless villains can't exist
|
||||
today.** This is the core schema fix.
|
||||
|
||||
### Identity model — descriptor as a fuzzy primary key
|
||||
Store a villain as:
|
||||
- `name` — now **optional**.
|
||||
- `descriptors` — accumulated distinctive physical tags heard over time
|
||||
("neck tattoo", "lips ink", "heavyset", "bald+beard").
|
||||
- `descriptor_embedding` — embedding of the accumulated distinctive tags, for
|
||||
semantic match against drifting phrasings.
|
||||
- `venue` — a strong disambiguator (the neck-tattoo reg at the Meadows ≠ the one
|
||||
at Wheeling, unless Brian travels).
|
||||
- `distinctiveness` — a weight; distinctive features (tattoos, scars, a name)
|
||||
score high, generic ones (age/race/glasses) near zero.
|
||||
|
||||
### Resolver — matching an incoming reference
|
||||
1. **Name present** → exact/fuzzy SQL match (entity desk). Done.
|
||||
2. **Descriptor present** → embed it, compare to `descriptor_embedding` of known
|
||||
villains **scoped to the current venue**, weighted by distinctiveness.
|
||||
3. **Confidence bands:**
|
||||
- **High** (distinctive + strong match) → surface the file; if live, a light
|
||||
confirm ("the neck-tattoo LAG from 3 weeks ago?").
|
||||
- **Medium/ambiguous** (several candidates, or a middling score) → **do NOT
|
||||
interrupt.** File a `needs_clarification` task to the review queue and stay
|
||||
quiet, OR ask only if it's decision-relevant right now.
|
||||
- **Generic-only** (no distinctive signal) → **refuse to guess.** Stay silent
|
||||
or ask for one distinctive detail ("anything that stands out — ink, chips,
|
||||
how he plays?"). Wrong-guy citation is worse than nothing.
|
||||
- **No match** → new villain; open a descriptor-keyed dossier.
|
||||
|
||||
### Seat = within-session alias only
|
||||
The live session keeps a `seat → villain` map so reads accumulate whether Brian
|
||||
says "seat 4" or "the tattoo guy." Seats evaporate when the session ends — they
|
||||
mean nothing next week.
|
||||
|
||||
## Confirmation loop (live, in chat)
|
||||
|
||||
Auto-merging on a fuzzy match is dangerous, so she **proposes and Brian confirms**
|
||||
in natural language:
|
||||
|
||||
> Brian: "neck tattoo guy just 3-bet me again"
|
||||
> Lyra: "The neck-tattoo LAG from the Meadows three weeks ago — the one who
|
||||
> stacked you with the flush? Or new guy?"
|
||||
> Brian: "yeah him" → reinforce identity · "nah different" → split, and learn
|
||||
> what distinguishes them.
|
||||
|
||||
Handles name-arrives-later for free: catch his name off Bravo → "merge neck-tattoo
|
||||
guy into 'Danny'" → history follows.
|
||||
|
||||
## The review interface (async, out-of-band)
|
||||
|
||||
Silence at the table ≠ forget it → it routes to a queue Brian clears at his pace.
|
||||
|
||||
### `/players` — villain file browser
|
||||
List: name-or-lead-descriptor, venue, category (feeder/risky/reg), hands
|
||||
observed, VPIP/PFR (when sample is real), last seen, distinctive tags. Detail
|
||||
view: reads, showdowns, notable hands (link to `/hand/{id}`), sessions seen,
|
||||
stats. Edit / rename / retag / delete / manual-merge.
|
||||
|
||||
### Resolution queue — two lanes
|
||||
- **Possible merges** — two profiles likely one person (high descriptor
|
||||
similarity + same venue, below auto-merge). Side-by-side → **Same guy** (merge)
|
||||
/ **Different** (split).
|
||||
- **Needs clarification** — a descriptor that matched several candidates, or a
|
||||
nameless villain the resolver couldn't place → pick match / **New guy**.
|
||||
|
||||
### Two rules that keep the queue from rotting
|
||||
1. **A rejected merge stays rejected** — record the pair as *known-distinct* so it
|
||||
never re-surfaces; start tracking the distinguishing tell.
|
||||
2. **Merge-candidate scan runs in the dream cycle**, not the hot path — nightly,
|
||||
compare descriptor embeddings within each venue, file new maybes. Zero live
|
||||
latency.
|
||||
|
||||
## Injection format & gating
|
||||
|
||||
A single system note, clearly marked as structured fact so she cites it (not
|
||||
confabulates), e.g.:
|
||||
|
||||
```
|
||||
STATS DESK — Neck-tattoo guy (Meadows, LAG/reg): seen 3×, last 2wk ago.
|
||||
vs you: hand #38 (AK, stacked off into his set). Reads: overfolds turn,
|
||||
3-bets light from the CO. Sample: 22 hands — VPIP 41 / PFR 28.
|
||||
```
|
||||
|
||||
Gate hard: inject only on a confident entity hit or a strong semantic score.
|
||||
Default to nothing. Never inject a generic-only guess.
|
||||
|
||||
## Honest limits
|
||||
|
||||
Never perfect. Some players are genuinely indistinguishable — fine. The system's
|
||||
only job: **right when there's signal, quiet when there isn't.**
|
||||
|
||||
## New data model (sketch)
|
||||
|
||||
- `poker_players`: `name` → nullable; add `descriptors TEXT`,
|
||||
`descriptor_embedding BLOB`, `distinctiveness REAL`.
|
||||
- `player_distinct_pairs(a_id, b_id, note, created_at)` — rejected merges.
|
||||
- `identity_queue(id, kind, player_ids, descriptor, context, session_id,
|
||||
confidence, status, resolution, created_at)` — kind ∈ {merge_candidate,
|
||||
needs_clarification}.
|
||||
- Live-session `seat → player_id` alias map (in-session only).
|
||||
|
||||
## Sequencing (after the trial-by-fire session — recall feeds on real data)
|
||||
|
||||
1. **Nameless identity + resolver** — schema, descriptor embedding, venue-scoped
|
||||
semantic match, distinctiveness gate. (Unblocks everything.)
|
||||
2. **Scouting-desk injection** — wire entity + pattern recall into
|
||||
`build_messages` as the gated STATS DESK note.
|
||||
3. **Confirmation loop** — the live propose/confirm/merge/split UX in the persona.
|
||||
4. **`/players` browser + resolution queue UI** — the async review interface.
|
||||
5. **Dream-cycle merge scan** — nightly candidate generation.
|
||||
6. **Pattern desk** — semantic recall over scars/notes/recaps for "this leak
|
||||
again."
|
||||
@@ -1,720 +0,0 @@
|
||||
# Poker Logging Service 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:** Turn `lyra/poker.py` into a standalone logging system-of-record with a complete REST API, a single source-of-truth tool/API contract, and a human UI to log and correct everything — usable by Brian with zero LLM dependency.
|
||||
|
||||
**Architecture:** Thin FastAPI routes wrap the existing (already-working) `poker.py` store functions; a declarative `poker_contract.py` pins operation names + required args so the REST API and Lyra's LLM tool specs can't drift; the web UI gets dumb capture inputs (2nd stack box on chat, quick inputs on the HUD) and correction controls. This is sub-project 1 of 2; Lyra's classifier/prompts (sub-project 2) are parked.
|
||||
|
||||
**Tech Stack:** Python 3.11+ (venv runs 3.14), FastAPI + uvicorn, SQLite (WAL), pytest, vanilla HTML/JS/CSS.
|
||||
|
||||
## Global Constraints
|
||||
|
||||
- Python files: start with `from __future__ import annotations`; 4-space indent; ruff `line-length = 100`, `target-version = "py311"`.
|
||||
- **`lyra/web/static/index.html` uses CRLF (`\r\n`) line endings and mixed tabs/spaces.** Every other static file (`session.html`, `style.css`, `nav.js`) and all Python use **LF + spaces**. Match the file you edit or you produce a noisy diff.
|
||||
- Pure data capture (stack / buy-in / cash-out / hand / read) must reach the store via the REST endpoints, **never** through the chat/LLM path.
|
||||
- `poker_contract.py` is the single source of truth: REST routes and `tools.py` specs must agree with it (enforced by a conformance test).
|
||||
- Web app runs via `lyra-web` (uvicorn) on `0.0.0.0:7078`. DB path from `LYRA_DB_PATH` (default `data/lyra.db`, WAL).
|
||||
- Test idiom: fixture sets `LYRA_DB_PATH` to a `tmp_path` file, stubs `llm.embed` (and `llm.complete` where needed), then `importlib.reload(memory)` **then** `importlib.reload(poker)` (order matters), then `importlib.reload(server)` for endpoint tests. Run with `.venv/bin/pytest` (or `uv run pytest`).
|
||||
- Existing store facts to respect: `start_session(...)` uses `fmt=` (column is `format`); `add_buyin` returns a float total; `log_stack` returns the `stack_state` dict `{current, buy_in, net}`; `end_session(cash_out, ...)` takes `cash_out` first; `hud()` returns `None` when no session; `_HAND_FIELDS = ("position","hole_cards","board","preflop","flop","turn","river","showdown","pot","result","stack_after","tag","lesson")`; `upsert_player(name, **fields)` returns an int player id; `tools.dispatch(name, args, ctx)` — `ctx` is a plain dict.
|
||||
|
||||
---
|
||||
|
||||
### Task 1: Contract module + tool-spec conformance test
|
||||
|
||||
**Files:**
|
||||
- Create: `lyra/poker_contract.py`
|
||||
- Create: `tests/test_poker_contract.py`
|
||||
|
||||
**Interfaces:**
|
||||
- Produces: `lyra.poker_contract.OPERATIONS: dict[str, dict]` and `CONTRACT_VERSION: int`. Each op value: `{"required": tuple[str,...], "llm_tool": str | None, "rest": tuple[str, str] | None}` where `rest` is `(METHOD, PATH)` with PATH exactly matching the FastAPI route template.
|
||||
|
||||
- [ ] **Step 1: Write the contract module**
|
||||
|
||||
`lyra/poker_contract.py`:
|
||||
```python
|
||||
from __future__ import annotations
|
||||
|
||||
# Single source of truth for poker logging operations. The REST API, Lyra's LLM
|
||||
# tool specs, the human UI, and (later) an MCP wrapper all derive from this.
|
||||
# `required` MUST match the `required` list in the matching tools.py spec.
|
||||
# `rest` PATH MUST match the FastAPI route template verbatim.
|
||||
CONTRACT_VERSION = 1
|
||||
|
||||
OPERATIONS: dict[str, dict] = {
|
||||
"start_session": {"required": (), "llm_tool": "start_session", "rest": ("POST", "/session")},
|
||||
"update_session": {"required": (), "llm_tool": "update_session", "rest": ("PATCH", "/session/{session_id}")},
|
||||
"end_session": {"required": ("cash_out",), "llm_tool": "end_session", "rest": None},
|
||||
"log_stack": {"required": ("amount",), "llm_tool": "log_stack", "rest": ("POST", "/session/stack")},
|
||||
"add_buyin": {"required": ("amount",), "llm_tool": "add_buyin", "rest": ("POST", "/session/buyin")},
|
||||
"log_hand": {"required": (), "llm_tool": "log_hand", "rest": ("POST", "/session/hand")},
|
||||
"update_hand": {"required": ("id",), "llm_tool": None, "rest": ("PATCH", "/hand/{hand_id}")},
|
||||
"add_read": {"required": ("note",), "llm_tool": "add_read", "rest": ("POST", "/session/read")},
|
||||
"update_player": {"required": ("id",), "llm_tool": None, "rest": ("PATCH", "/player/{player_id}")},
|
||||
}
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Write the failing conformance test**
|
||||
|
||||
`tests/test_poker_contract.py`:
|
||||
```python
|
||||
from __future__ import annotations
|
||||
|
||||
from lyra import tools
|
||||
from lyra.poker_contract import OPERATIONS
|
||||
|
||||
|
||||
def test_llm_tool_required_args_match_contract():
|
||||
for op, decl in OPERATIONS.items():
|
||||
name = decl["llm_tool"]
|
||||
if not name:
|
||||
continue
|
||||
spec = tools.TOOLS[name]["spec"]
|
||||
required = set(spec["function"]["parameters"]["required"])
|
||||
assert required == set(decl["required"]), (
|
||||
f"{op}: tools spec required {required} != contract {set(decl['required'])}"
|
||||
)
|
||||
```
|
||||
|
||||
- [ ] **Step 3: Run the test**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_contract.py -v`
|
||||
Expected: PASS (the contract's `required` tuples were copied from the live specs).
|
||||
|
||||
- [ ] **Step 4: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/poker_contract.py tests/test_poker_contract.py
|
||||
git commit -m "feat: poker operation contract + tool-spec conformance test"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 2: Direct capture endpoints (stack / buy-in / start)
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/web/server.py` (add three routes inside `create_app`, near the existing `PATCH /session/{session_id}` at server.py:116)
|
||||
- Create: `tests/test_poker_api.py`
|
||||
|
||||
**Interfaces:**
|
||||
- Consumes: `poker.log_stack(amount, note=None)`, `poker.add_buyin(amount)`, `poker.start_session(venue=, stakes=, game=, fmt=, buy_in=, mantra=)`, `poker.live_session()`.
|
||||
- Produces: `POST /session/stack` → `{ok, stack}` or `{ok:false, error}`; `POST /session/buyin` → `{ok, buy_in_total}`; `POST /session` → `{ok, id}`.
|
||||
|
||||
- [ ] **Step 1: Write the failing endpoint tests**
|
||||
|
||||
`tests/test_poker_api.py`:
|
||||
```python
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(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.web.server as server
|
||||
importlib.reload(server)
|
||||
from fastapi.testclient import TestClient
|
||||
return TestClient(server.app), poker
|
||||
|
||||
|
||||
def test_post_stack_logs_and_returns_state(client):
|
||||
c, poker = client
|
||||
poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
|
||||
r = c.post("/session/stack", json={"amount": 373})
|
||||
assert r.status_code == 200
|
||||
body = r.json()
|
||||
assert body["ok"] is True
|
||||
assert body["stack"]["current"] == 373
|
||||
assert body["stack"]["net"] == pytest.approx(-27)
|
||||
|
||||
|
||||
def test_post_stack_without_session_errors(client):
|
||||
c, _ = client
|
||||
r = c.post("/session/stack", json={"amount": 373})
|
||||
assert r.json()["ok"] is False
|
||||
assert "error" in r.json()
|
||||
|
||||
|
||||
def test_post_buyin_increments_total(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/buyin", json={"amount": 200})
|
||||
assert r.json()["buy_in_total"] == pytest.approx(600)
|
||||
|
||||
|
||||
def test_post_session_starts_live(client):
|
||||
c, poker = client
|
||||
r = c.post("/session", json={"venue": "Wheeling", "stakes": "1/3", "buy_in": 400})
|
||||
sid = r.json()["id"]
|
||||
assert poker.live_session()["id"] == sid
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Run to verify it fails**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py -v`
|
||||
Expected: FAIL with 404s (routes not defined). If it errors with "No module named 'httpx'", run `.venv/bin/pip install httpx` (TestClient needs it).
|
||||
|
||||
- [ ] **Step 3: Add the three routes**
|
||||
|
||||
In `lyra/web/server.py`, immediately after the `PATCH /session/{session_id}` handler (server.py:122), add:
|
||||
```python
|
||||
@app.post("/session/stack")
|
||||
async def session_log_stack(request: Request) -> dict:
|
||||
"""Log Brian's current stack directly (no LLM). Server-stamps the time."""
|
||||
body = await request.json()
|
||||
try:
|
||||
amount = float(body.get("amount"))
|
||||
except (TypeError, ValueError):
|
||||
return {"ok": False, "error": "amount must be a number"}
|
||||
note = (body.get("note") or "").strip() or None
|
||||
try:
|
||||
state = await asyncio.to_thread(poker.log_stack, amount, note)
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "stack logged (direct)", amount=amount)
|
||||
return {"ok": True, "stack": state}
|
||||
|
||||
@app.post("/session/buyin")
|
||||
async def session_add_buyin(request: Request) -> dict:
|
||||
"""Add a buy-in/rebuy directly (no LLM)."""
|
||||
body = await request.json()
|
||||
try:
|
||||
amount = float(body.get("amount"))
|
||||
except (TypeError, ValueError):
|
||||
return {"ok": False, "error": "amount must be a number"}
|
||||
try:
|
||||
total = await asyncio.to_thread(poker.add_buyin, amount)
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "buyin added (direct)", amount=amount)
|
||||
return {"ok": True, "buy_in_total": total}
|
||||
|
||||
@app.post("/session")
|
||||
async def session_start(request: Request) -> dict:
|
||||
"""Open a new live session directly (no LLM)."""
|
||||
body = await request.json()
|
||||
sid = await asyncio.to_thread(lambda: poker.start_session(
|
||||
venue=body.get("venue"), stakes=body.get("stakes"),
|
||||
game=body.get("game") or "NLH", fmt=body.get("format") or "cash",
|
||||
buy_in=body.get("buy_in") or 0, mantra=body.get("mantra"),
|
||||
))
|
||||
logbus.log("info", "poker session started (direct)", id=sid)
|
||||
return {"ok": True, "id": sid}
|
||||
```
|
||||
|
||||
- [ ] **Step 4: Run to verify it passes**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py -v`
|
||||
Expected: PASS (4 tests).
|
||||
|
||||
- [ ] **Step 5: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/web/server.py tests/test_poker_api.py
|
||||
git commit -m "feat: direct REST endpoints for stack/buyin/start-session (no LLM)"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 3: Hands API (log / edit / delete)
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/poker.py` (add `update_hand` near `log_hand` at poker.py:558)
|
||||
- Modify: `lyra/web/server.py` (add routes after the Task 2 routes)
|
||||
- Modify: `tests/test_poker_api.py` (add tests)
|
||||
|
||||
**Interfaces:**
|
||||
- Consumes: `poker.log_hand(**fields)`, `poker.get_hand(id)`, `poker.delete_entry("hand", id)`, `_HAND_FIELDS`.
|
||||
- Produces: `poker.update_hand(hand_id, **fields) -> dict | None`; `POST /session/hand` → `{ok, id}`; `PATCH /hand/{hand_id}` → `{ok, hand}`; `DELETE /hand/{hand_id}` → `{ok}`.
|
||||
|
||||
- [ ] **Step 1: Write the failing tests**
|
||||
|
||||
Append to `tests/test_poker_api.py`:
|
||||
```python
|
||||
def test_post_hand_edit_and_delete(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/hand", json={"position": "BTN", "hole_cards": "22", "result": 120})
|
||||
assert r.json()["ok"] is True
|
||||
hid = r.json()["id"]
|
||||
r2 = c.patch(f"/hand/{hid}", json={"hole_cards": "2c2d"})
|
||||
assert r2.json()["ok"] is True
|
||||
assert r2.json()["hand"]["hole_cards"] == "2c2d"
|
||||
r3 = c.delete(f"/hand/{hid}")
|
||||
assert r3.json()["ok"] is True
|
||||
assert poker.get_hand(hid) is None
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Run to verify it fails**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py::test_post_hand_edit_and_delete -v`
|
||||
Expected: FAIL (404 on `/session/hand`).
|
||||
|
||||
- [ ] **Step 3: Add `update_hand` to the store**
|
||||
|
||||
In `lyra/poker.py`, immediately after `log_hand` (poker.py:558), add:
|
||||
```python
|
||||
def update_hand(hand_id: int, **fields) -> dict | None:
|
||||
"""Edit a logged hand's flat fields (fix a mislabeled board, result, villain).
|
||||
Only known columns are touched. Returns the updated hand row or None."""
|
||||
sets, vals = [], []
|
||||
for k, v in fields.items():
|
||||
if k in _HAND_FIELDS and v is not None:
|
||||
sets.append(f"{k} = ?")
|
||||
vals.append(v)
|
||||
if sets:
|
||||
conn = _c()
|
||||
with conn:
|
||||
conn.execute(f"UPDATE poker_hands SET {', '.join(sets)} WHERE id = ?",
|
||||
(*vals, hand_id))
|
||||
return get_hand(hand_id)
|
||||
```
|
||||
|
||||
- [ ] **Step 4: Add the three routes**
|
||||
|
||||
In `lyra/web/server.py`, after the Task 2 routes, add:
|
||||
```python
|
||||
@app.post("/session/hand")
|
||||
async def session_log_hand(request: Request) -> dict:
|
||||
"""Log a hand directly with flat fields (no LLM parse)."""
|
||||
body = await request.json()
|
||||
try:
|
||||
hid = await asyncio.to_thread(lambda: poker.log_hand(**body))
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "hand logged (direct)", id=hid)
|
||||
return {"ok": True, "id": hid}
|
||||
|
||||
@app.patch("/hand/{hand_id}")
|
||||
async def hand_update(hand_id: int, request: Request) -> dict:
|
||||
"""Edit a logged hand's flat fields."""
|
||||
body = await request.json()
|
||||
h = await asyncio.to_thread(lambda: poker.update_hand(hand_id, **body))
|
||||
logbus.log("info", "hand edited", id=hand_id, fields=list(body))
|
||||
return {"ok": h is not None, "hand": h}
|
||||
|
||||
@app.delete("/hand/{hand_id}")
|
||||
async def hand_delete(hand_id: int) -> dict:
|
||||
"""Delete a logged hand."""
|
||||
ok = await asyncio.to_thread(poker.delete_entry, "hand", hand_id)
|
||||
return {"ok": ok}
|
||||
```
|
||||
|
||||
- [ ] **Step 5: Run to verify it passes**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py -v`
|
||||
Expected: PASS (all tests, including the new hand test).
|
||||
|
||||
- [ ] **Step 6: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/poker.py lyra/web/server.py tests/test_poker_api.py
|
||||
git commit -m "feat: hands API — log_hand endpoint, update_hand store fn, edit/delete routes"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 4: Reads/players API + route conformance
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/poker.py` (add `update_player` near `upsert_player`)
|
||||
- Modify: `lyra/web/server.py` (add routes)
|
||||
- Modify: `tests/test_poker_api.py` (add tests)
|
||||
- Modify: `tests/test_poker_contract.py` (add route-coverage test)
|
||||
|
||||
**Interfaces:**
|
||||
- Consumes: `poker.add_read(note=, name=, ...)`, `poker.upsert_player(name, **fields)`.
|
||||
- Produces: `poker.update_player(player_id, **fields) -> dict | None`; `POST /session/read` → `{ok, id}`; `PATCH /player/{player_id}` → `{ok, player}`.
|
||||
|
||||
- [ ] **Step 1: Write the failing tests**
|
||||
|
||||
Append to `tests/test_poker_api.py`:
|
||||
```python
|
||||
def test_post_read(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/read", json={"note": "3-bets light", "name": "James K"})
|
||||
assert r.json()["ok"] is True
|
||||
assert isinstance(r.json()["id"], int)
|
||||
|
||||
|
||||
def test_rename_player_fixes_mislabel(client):
|
||||
c, poker = client
|
||||
pid = poker.upsert_player("Dave the rock", category="reg")
|
||||
r = c.patch(f"/player/{pid}", json={"name": "Dave the mechanic"})
|
||||
assert r.json()["ok"] is True
|
||||
assert r.json()["player"]["name"] == "Dave the mechanic"
|
||||
```
|
||||
|
||||
Append to `tests/test_poker_contract.py`:
|
||||
```python
|
||||
def test_rest_routes_registered():
|
||||
import lyra.web.server as server
|
||||
registered = set()
|
||||
for route in server.app.routes:
|
||||
methods = getattr(route, "methods", None)
|
||||
path = getattr(route, "path", None)
|
||||
if not methods or not path:
|
||||
continue
|
||||
for m in methods:
|
||||
registered.add((m, path))
|
||||
for op, decl in OPERATIONS.items():
|
||||
if not decl["rest"]:
|
||||
continue
|
||||
method, path = decl["rest"]
|
||||
assert (method, path) in registered, f"{op}: {method} {path} not registered"
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Run to verify it fails**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py::test_rename_player_fixes_mislabel tests/test_poker_contract.py::test_rest_routes_registered -v`
|
||||
Expected: FAIL (404 on `/player/...`; route-coverage missing several POST/PATCH paths).
|
||||
|
||||
- [ ] **Step 3: Add `update_player` to the store**
|
||||
|
||||
In `lyra/poker.py`, immediately after `upsert_player` (find it near poker.py:1010), add:
|
||||
```python
|
||||
_PLAYER_FIELDS = ("name", "venue", "description", "tendencies", "adjustment", "category")
|
||||
|
||||
|
||||
def update_player(player_id: int, **fields) -> dict | None:
|
||||
"""Edit a player's dossier (rename, fix tendencies/category). Returns the row or None."""
|
||||
sets, vals = [], []
|
||||
for k, v in fields.items():
|
||||
if k in _PLAYER_FIELDS and v is not None:
|
||||
sets.append(f"{k} = ?")
|
||||
vals.append(v)
|
||||
if sets:
|
||||
conn = _c()
|
||||
with conn:
|
||||
conn.execute(f"UPDATE poker_players SET {', '.join(sets)} WHERE id = ?",
|
||||
(*vals, player_id))
|
||||
row = _c().execute("SELECT * FROM poker_players WHERE id = ?", (player_id,)).fetchone()
|
||||
return dict(row) if row else None
|
||||
```
|
||||
|
||||
- [ ] **Step 4: Add the two routes**
|
||||
|
||||
In `lyra/web/server.py`, after the Task 3 routes, add:
|
||||
```python
|
||||
@app.post("/session/read")
|
||||
async def session_add_read(request: Request) -> dict:
|
||||
"""Log a read directly (no LLM); upserts the villain file when name is given."""
|
||||
body = await request.json()
|
||||
rid = await asyncio.to_thread(lambda: poker.add_read(
|
||||
note=body.get("note") or "", seat=body.get("seat"), name=body.get("name"),
|
||||
tendencies=body.get("tendencies"), adjustment=body.get("adjustment"),
|
||||
description=body.get("description"), category=body.get("category"),
|
||||
venue=body.get("venue"),
|
||||
))
|
||||
return {"ok": True, "id": rid}
|
||||
|
||||
@app.patch("/player/{player_id}")
|
||||
async def player_update(player_id: int, request: Request) -> dict:
|
||||
"""Edit a player's dossier (rename, fix tendencies)."""
|
||||
body = await request.json()
|
||||
p = await asyncio.to_thread(lambda: poker.update_player(player_id, **body))
|
||||
logbus.log("info", "player edited", id=player_id, fields=list(body))
|
||||
return {"ok": p is not None, "player": p}
|
||||
```
|
||||
|
||||
- [ ] **Step 5: Run to verify it passes**
|
||||
|
||||
Run: `.venv/bin/pytest tests/test_poker_api.py tests/test_poker_contract.py -v`
|
||||
Expected: PASS (all API tests + both conformance tests).
|
||||
|
||||
- [ ] **Step 6: Run the full suite (no regressions)**
|
||||
|
||||
Run: `.venv/bin/pytest -q`
|
||||
Expected: PASS (existing poker/tools/chat tests still green).
|
||||
|
||||
- [ ] **Step 7: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/poker.py lyra/web/server.py tests/test_poker_api.py tests/test_poker_contract.py
|
||||
git commit -m "feat: reads/players API + REST route conformance test"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 5: Chat-page stack quick-capture (2nd input box)
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/web/static/index.html` (**CRLF + tabs** — add markup + JS)
|
||||
- Modify: `lyra/web/static/style.css` (LF + spaces — add styling)
|
||||
|
||||
**Interfaces:**
|
||||
- Consumes: `POST /session/stack` (Task 2). Reads `currentSession` and the Live Log DOM (`#thinkingContent`, `#thinkingEmpty`) already present in index.html.
|
||||
- Produces: a stack-only input that logs without any chat/LLM call.
|
||||
|
||||
- [ ] **Step 1: Add the input row markup**
|
||||
|
||||
In `lyra/web/static/index.html`, insert **between** the `<div id="input">…</div>` block (ends ~index.html:125) and `<nav id="tabbar">` (index.html:128). **Use CRLF + tab indentation to match the file.**
|
||||
```html
|
||||
<!-- Stack quick-capture (no LLM): type a number -> logs current stack -->
|
||||
<div id="stackQuick">
|
||||
<input id="stackQuickInput" type="number" inputmode="decimal" placeholder="Stack $" aria-label="Log current stack">
|
||||
<button id="stackQuickBtn" type="button" title="Log stack (no chat)">Log</button>
|
||||
</div>
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Add the JS**
|
||||
|
||||
In the `<script>` of `index.html`, near `sendMessage` (index.html:299), add (CRLF + tabs):
|
||||
```javascript
|
||||
function liveLogLine(text) {
|
||||
const content = document.getElementById("thinkingContent");
|
||||
const empty = document.getElementById("thinkingEmpty");
|
||||
if (empty) empty.style.display = "none";
|
||||
const div = document.createElement("div");
|
||||
div.className = "thinking-event";
|
||||
div.textContent = text;
|
||||
content.appendChild(div);
|
||||
content.scrollTop = content.scrollHeight;
|
||||
}
|
||||
|
||||
async function logStackQuick() {
|
||||
const el = document.getElementById("stackQuickInput");
|
||||
const raw = (el.value || "").replace(/[^0-9.]/g, "");
|
||||
if (!raw) return;
|
||||
const amount = Number(raw);
|
||||
try {
|
||||
const r = await fetch("/session/stack", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ amount })
|
||||
});
|
||||
const data = await r.json();
|
||||
if (!data.ok) { liveLogLine("⚠ " + (data.error || "stack not logged")); return; }
|
||||
const t = new Date().toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
|
||||
const net = (data.stack && data.stack.net != null)
|
||||
? ` (net ${data.stack.net >= 0 ? "+" : ""}${data.stack.net})` : "";
|
||||
liveLogLine(`💰 $${amount} logged · ${t}${net}`);
|
||||
el.value = "";
|
||||
} catch (e) {
|
||||
liveLogLine("⚠ stack log failed: " + e.message);
|
||||
}
|
||||
}
|
||||
document.getElementById("stackQuickBtn").addEventListener("click", logStackQuick);
|
||||
document.getElementById("stackQuickInput").addEventListener("keydown", (e) => {
|
||||
if (e.key === "Enter") { e.preventDefault(); logStackQuick(); }
|
||||
});
|
||||
```
|
||||
|
||||
- [ ] **Step 3: Add styling**
|
||||
|
||||
In `lyra/web/static/style.css` (LF + spaces), add:
|
||||
```css
|
||||
#stackQuick {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
align-items: center;
|
||||
padding: 6px 12px;
|
||||
border-top: 1px solid var(--border, #222);
|
||||
}
|
||||
#stackQuick input {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
padding: 8px 10px;
|
||||
background: var(--panel, #111);
|
||||
color: inherit;
|
||||
border: 1px solid var(--border, #333);
|
||||
border-radius: 8px;
|
||||
}
|
||||
#stackQuick button {
|
||||
padding: 8px 14px;
|
||||
background: var(--accent, #ff7a18);
|
||||
color: #000;
|
||||
border: none;
|
||||
border-radius: 8px;
|
||||
font-weight: 600;
|
||||
}
|
||||
```
|
||||
|
||||
- [ ] **Step 4: Verify manually**
|
||||
|
||||
Start the app: `.venv/bin/python -m lyra.web.server` (serves on :7078). With a live session (start one via the HUD or `curl -XPOST localhost:7078/session -d '{"buy_in":400}' -H 'Content-Type: application/json'`):
|
||||
- The stack box appears below the message input, above the nav icons.
|
||||
- Type `350`, press Enter → a `💰 $350 logged · …` line appears in the Live Log, the box clears, and **no chat bubble is added**.
|
||||
- Confirm persisted: `curl -s localhost:7078/session/data | python -m json.tool` shows `stack.current == 350`.
|
||||
|
||||
- [ ] **Step 5: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/web/static/index.html lyra/web/static/style.css
|
||||
git commit -m "feat: stack quick-capture box on chat page (no LLM)"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 6: HUD quick-capture + correction controls
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/web/static/session.html` (LF + spaces — Stack card markup, villain rename control, JS functions)
|
||||
|
||||
**Interfaces:**
|
||||
- Consumes: `POST /session/stack`, `POST /session/buyin` (Task 2), `PATCH /session/{id}` (existing), `PATCH /player/{id}` (Task 4). Reads existing globals `curSession`, `refresh()`, and the villain render block.
|
||||
|
||||
- [ ] **Step 1: Add quick inputs to the Stack card**
|
||||
|
||||
In `lyra/web/static/session.html`, replace the Stack card block (session.html:280-289) with the same block plus a `quick` row before its closing `</div>`:
|
||||
```javascript
|
||||
<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 || [])}
|
||||
<div class="quick">
|
||||
<input id="qStack" type="number" inputmode="decimal" placeholder="Stack $" onkeydown="if(event.key==='Enter')postStack()">
|
||||
<button onclick="postStack()">Log stack</button>
|
||||
<input id="qBuyin" type="number" inputmode="decimal" placeholder="Buy-in $" onkeydown="if(event.key==='Enter')postBuyin()">
|
||||
<button onclick="postBuyin()">Add buy-in</button>
|
||||
<input id="qCashout" type="number" inputmode="decimal" placeholder="Cash out $" onkeydown="if(event.key==='Enter')postCashout()">
|
||||
<button onclick="postCashout()">Cash out</button>
|
||||
</div>
|
||||
</div>
|
||||
```
|
||||
|
||||
- [ ] **Step 2: Add the quick-capture + rename JS functions**
|
||||
|
||||
In the `<script>` of `session.html`, near `saveEdit()` (session.html:192), add:
|
||||
```javascript
|
||||
async function postQuick(url, amount, body){
|
||||
const r = await fetch(url, { method: 'POST', headers: {'Content-Type':'application/json'},
|
||||
body: JSON.stringify(body || { amount }) });
|
||||
const d = await r.json();
|
||||
if(!d.ok){ alert(d.error || 'failed'); return false; }
|
||||
refresh(); return true;
|
||||
}
|
||||
function numVal(id){ const el = document.getElementById(id); return Number((el.value||'').replace(/[^0-9.]/g,'')); }
|
||||
async function postStack(){ const v = numVal('qStack'); if(v) { if(await postQuick('/session/stack', v)) document.getElementById('qStack').value=''; } }
|
||||
async function postBuyin(){ const v = numVal('qBuyin'); if(v) { if(await postQuick('/session/buyin', v)) document.getElementById('qBuyin').value=''; } }
|
||||
async function postCashout(){
|
||||
if(!curSession) return;
|
||||
const v = numVal('qCashout'); if(!v) return;
|
||||
const r = await fetch('/session/'+curSession.id, { method:'PATCH', headers:{'Content-Type':'application/json'},
|
||||
body: JSON.stringify({ cash_out: v }) });
|
||||
if(!(await r.json()).ok){ alert('failed'); return; }
|
||||
document.getElementById('qCashout').value=''; refresh();
|
||||
}
|
||||
async function renamePlayer(id, current){
|
||||
const name = prompt('Rename player', current || ''); if(!name) return;
|
||||
const r = await fetch('/player/'+id, { method:'PATCH', headers:{'Content-Type':'application/json'},
|
||||
body: JSON.stringify({ name }) });
|
||||
if(!(await r.json()).ok){ alert('failed'); return; }
|
||||
refresh();
|
||||
}
|
||||
```
|
||||
|
||||
- [ ] **Step 3: Add the rename control to the villains list**
|
||||
|
||||
In `session.html`, find the villains render block in `render(data)` (it maps over `data.villains` / the `villains` array). For each villain item, add a rename affordance next to the name, using the player id field present on the villain row (commonly `v.id` or `v.player_id` — use whichever the bundle provides):
|
||||
```javascript
|
||||
<button class="mini" title="Rename / fix" onclick="renamePlayer(${v.id}, '${esc(v.name||'')}')">✎</button>
|
||||
```
|
||||
Read the existing villain block first to splice this in cleanly and confirm the id field name.
|
||||
|
||||
- [ ] **Step 4: Add minimal styling**
|
||||
|
||||
In the inline `<style>` of `session.html`, add:
|
||||
```css
|
||||
.quick { display:flex; flex-wrap:wrap; gap:6px; margin-top:12px; }
|
||||
.quick input { width:96px; padding:7px 9px; background:#111; color:inherit; border:1px solid #333; border-radius:8px; }
|
||||
.quick button { padding:7px 11px; background:var(--accent,#ff7a18); color:#000; border:none; border-radius:8px; font-weight:600; }
|
||||
button.mini { background:transparent; border:none; color:#888; cursor:pointer; padding:0 4px; }
|
||||
```
|
||||
|
||||
- [ ] **Step 5: Verify manually**
|
||||
|
||||
With the app running and a live session, open `/session`:
|
||||
- Log a stack via `qStack` → sparkline + net update without a chat call.
|
||||
- Add a buy-in via `qBuyin` → "bought in" total rises.
|
||||
- Enter a cash-out via `qCashout` → session net updates.
|
||||
- Click ✎ on a villain, rename it → name changes after refresh. Confirm via `curl -s localhost:7078/session/data`.
|
||||
|
||||
- [ ] **Step 6: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/web/static/session.html
|
||||
git commit -m "feat: HUD quick-capture (stack/buyin/cashout) + villain rename"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Task 7: iOS-PWA bottom safe-area gap fix
|
||||
|
||||
**Files:**
|
||||
- Modify: `lyra/web/static/style.css` (bottom nav / container safe-area)
|
||||
|
||||
**Interfaces:** none (visual fix). The empty band below the nav icons is the home-indicator inset not being consumed by `#tabbar`.
|
||||
|
||||
- [ ] **Step 1: Load the iOS-PWA skill**
|
||||
|
||||
Invoke the `building-ios-pwas` skill and follow its guidance for safe-area / `100dvh` handling before editing. The current `#tabbar` (style.css:921-952) applies `env(safe-area-inset-left/right)` and `padding-bottom: 6px`, but does **not** add `env(safe-area-inset-bottom)` — the likely cause.
|
||||
|
||||
- [ ] **Step 2: Apply the safe-area fix**
|
||||
|
||||
In `lyra/web/static/style.css`, in the mobile `#tabbar` rule (style.css:921-929), change the bottom padding to consume the inset, and ensure the bar is pinned:
|
||||
```css
|
||||
#tabbar {
|
||||
/* …existing flex/border rules… */
|
||||
position: fixed;
|
||||
left: 0;
|
||||
right: 0;
|
||||
bottom: 0;
|
||||
padding-bottom: calc(6px + env(safe-area-inset-bottom));
|
||||
}
|
||||
```
|
||||
And ensure the chat scroll container reserves space for the bar so content isn't hidden behind it (match the container selector used at style.css:836-852):
|
||||
```css
|
||||
@media (max-width: 768px) {
|
||||
#messages {
|
||||
padding-bottom: calc(64px + env(safe-area-inset-bottom));
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
- [ ] **Step 3: Verify on device**
|
||||
|
||||
Open the PWA (Add to Home Screen) on iPhone:
|
||||
- The empty band below the icons is gone; the nav sits flush above the home indicator.
|
||||
- The stack quick-capture box (Task 5) sits directly above the nav.
|
||||
- Open the keyboard: `body.kb` still hides the tabbar (style.css:952) and the input pins to the keyboard — confirm no regression.
|
||||
- If the gap persists or content clips, follow the `building-ios-pwas` skill's `100dvh`/`visualViewport` guidance and iterate.
|
||||
|
||||
- [ ] **Step 4: Commit**
|
||||
|
||||
```bash
|
||||
git add lyra/web/static/style.css
|
||||
git commit -m "fix: consume iOS home-indicator safe-area inset under bottom nav"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Self-Review
|
||||
|
||||
**Spec coverage:**
|
||||
- Complete API surface (create/update/delete per entity) → Tasks 2 (stack/buyin/start), 3 (hands), 4 (reads/players); existing PATCH/DELETE session + entry routes retained.
|
||||
- Single documented/versioned tool-API contract → Task 1 (`poker_contract.py`, `CONTRACT_VERSION`) + conformance tests (Tasks 1, 4).
|
||||
- Human UI to log + edit/correct → Tasks 5 (chat 2nd box), 6 (HUD quick inputs + villain rename + existing edit form/delete).
|
||||
- Pure capture never touches LLM → all capture goes through REST endpoints (Tasks 2–6); verified in manual steps (no chat bubble).
|
||||
- 2nd input box + PWA fix → Tasks 5, 7.
|
||||
- Non-goals respected: no classifier/prompts, no MI50 tool enablement, no MCP, buy-in stays scalar (`add_buyin` increments `buy_in_total`).
|
||||
|
||||
**Placeholder scan:** All code steps contain complete code. The one "locate the block" instruction (Task 6 Step 3, villain rename) provides the exact button snippet and names the id-field ambiguity to resolve by reading the file — not a placeholder, a grounded splice.
|
||||
|
||||
**Type consistency:** `poker_contract.OPERATIONS` shape is consistent across Tasks 1 and 4; REST paths in the contract (`/session/stack`, `/session/buyin`, `/session`, `/session/hand`, `/hand/{hand_id}`, `/session/read`, `/player/{player_id}`, `/session/{session_id}`) match the routes added in Tasks 2–4 exactly; `update_hand`/`update_player` signatures match their callers; response shapes (`{ok, stack}`, `{ok, buy_in_total}`, `{ok, id}`, `{ok, hand}`, `{ok, player}`) are used consistently in tests and routes.
|
||||
|
||||
**Open implementation note:** Task 6 Step 3 requires reading `session.html`'s villain render to confirm the player id field name (`v.id` vs `v.player_id`) before splicing the rename button.
|
||||
@@ -1,158 +0,0 @@
|
||||
# Poker logging service + message-type prompts
|
||||
|
||||
- **Date:** 2026-06-28
|
||||
- **Status:** Sub-project 1 spec ready for review; sub-project 2 parked.
|
||||
- **Branch:** `feat/poker-mode-prompts`
|
||||
|
||||
## Origin
|
||||
|
||||
This started as "make Lyra's poker replies less generic" (message-type-specific prompts). During design we decided to **build the logging tool first** as a standalone system of record with a clean API and a human-usable UI, then wire Lyra in as a *client* of it. Rationale:
|
||||
|
||||
- Brian can log and **correct** data himself, independent of whether Lyra parsed it right (she mislabeled "Dave the rock" vs "Dave the mechanic" mid-session).
|
||||
- The data stops being hostage to the agent. Lyra becomes one client among potentially several.
|
||||
- It's reusable: RTO (the solver) and a **fine-tuned poker model on the MI50** could consume the same hand/session data through the same contract.
|
||||
|
||||
## Decomposition
|
||||
|
||||
Two sub-projects, built and shipped in order.
|
||||
|
||||
### Sub-project 1 — Poker logging service *(this spec)*
|
||||
Harden `lyra/poker.py` into a well-bounded store, expose a **complete REST API** over it, define a **stable, documented tool/API contract**, and build the human UI to log/edit/correct everything. Fully usable by Brian alone, zero LLM dependency.
|
||||
|
||||
### Sub-project 2 — Lyra wiring *(parked; summarized at the end)*
|
||||
Message-type classifier + type-specific prompt fragments; Lyra's tools call the sub-project 1 service. Separately, enabling tool-calling on the MI50 backend so a fine-tuned poker model can drive the same contract.
|
||||
|
||||
**Why the contract is first-class:** in every design (in-process, REST, MCP) the *model* never calls the API directly — it emits a tool-call and the host app executes it. So what lets the cloud model, the MI50 fine-tune, RTO, and a human UI all interoperate is a single **stable tool/API schema** (operation names + JSON arg schemas). That contract is the training target for the fine-tune and the seam for every backend. MCP is deferred: it's a thin wrap over the same service, worth adding only when a *second host application* appears.
|
||||
|
||||
---
|
||||
|
||||
# Sub-project 1 — Poker logging service
|
||||
|
||||
## Goals
|
||||
|
||||
1. A complete API surface over the poker data model — create/read/update/delete for every entity, not just the few edit/delete endpoints exposed today.
|
||||
2. A single **documented, versioned tool/API contract** that the REST API, Lyra's LLM tools, the human UI, a future MCP wrapper, and the MI50 fine-tune all share.
|
||||
3. A human UI to **log** (fast capture) and **edit/correct** (fix Lyra's mistakes) every entity.
|
||||
4. The 2nd input box (stack quick-capture) and the iOS-PWA bottom safe-area fix.
|
||||
5. Pure data capture never touches the LLM.
|
||||
|
||||
## Non-goals
|
||||
|
||||
- Lyra's classifier / prompt fragments (sub-project 2).
|
||||
- Enabling tools on the MI50 backend (sub-project 2).
|
||||
- MCP wrapper (deferred until a second host app exists).
|
||||
- Itemized buy-in history — buy-ins stay a single `buy_in_total` scalar.
|
||||
- Rewriting the SQLite schema; we build on the existing tables.
|
||||
|
||||
## Current state (what exists)
|
||||
|
||||
- **Store & logic:** `lyra/poker.py` — schema at `poker.py:21` (tables `poker_sessions`, `poker_hands`, `poker_stack_log`, `poker_rituals`, `poker_players`, `player_reads`, `player_observations`). Functions: `start_session` (157), `add_buyin` (389), `log_stack` (407), `stack_state` (446), `update_session` (362), `end_session` (515), `log_hand` (541, flat/no-LLM), `record_hand` (770, LLM-parses shorthand), `add_read` (1010), `hud` (1245).
|
||||
- **Exposed endpoints (`lyra/web/server.py`):** `GET /session/data` (hud), `PATCH /session/{id}`, `DELETE /session/entry/{kind}/{id}`, `GET/DELETE /history`, `GET /hand/{id}/data`, `POST /hand/{id}/reconstruct`, `GET /hands/data`, `GET /recap/...`. **No** direct create endpoint for stack/buyin/hand/read/session — those are reachable only through chat → tool-calling.
|
||||
- **UI:** `index.html` (chat), `session.html` (live HUD: stack card + sparkline + a PATCH-based edit form via `saveEdit()` at `session.html:192`, and `del(kind,id)` at `211`), `history.html`, `hand.html`.
|
||||
- **Tool specs:** `lyra/tools.py` already defines arg schemas for each operation (`_f(...)` specs, `tools.py:469-658`) — the embryo of the contract.
|
||||
|
||||
## Design
|
||||
|
||||
### 1. Store layer — harden `poker.py`
|
||||
|
||||
Keep the existing functions and tables; tighten the module into a clean service boundary so both the REST layer and Lyra's tools call the *same* functions. Each operation: validates input, resolves the target session (`_resolve`), writes, returns a consistent dict. No behavior change to existing callers; this is consolidation, not a rewrite.
|
||||
|
||||
### 2. The tool/API contract *(first-class deliverable)*
|
||||
|
||||
A single source-of-truth document + schema defining every operation: name, purpose, JSON arg schema, return shape, and which REST route + which LLM tool map to it. Versioned (e.g. `contract_version: 1`). Lives at `docs/POKER_API.md` (or a machine-readable `poker_contract.py` that both the REST routes and `tools.py` specs derive from — preferred, so they can't drift).
|
||||
|
||||
Operations (the canonical set):
|
||||
|
||||
| Operation | Args | Entity |
|
||||
|---|---|---|
|
||||
| `start_session` | venue, stakes, game, format, buy_in, mantra | session |
|
||||
| `update_session` | venue, stakes, game, format, buy_in_total, cash_out, mantra, mood | session |
|
||||
| `end_session` | cash_out, mood | session |
|
||||
| `delete_session` | id | session |
|
||||
| `log_stack` | amount, note | stack entry |
|
||||
| `delete_stack` | id | stack entry |
|
||||
| `add_buyin` | amount | session (increments buy_in_total) |
|
||||
| `log_hand` | position, hole_cards, board, streets…, pot, result, tag, lesson | hand |
|
||||
| `record_hand` | shorthand (LLM-parsed) | hand |
|
||||
| `update_hand` | id, any hand field | hand |
|
||||
| `delete_hand` | id | hand |
|
||||
| `add_read` | note, name, seat, tendencies, adjustment, category, venue | player/read |
|
||||
| `update_read` / `update_player` | id, fields | player/read |
|
||||
| `delete_read` | id | player/read |
|
||||
| rituals: `scar_note`, `confidence_bank`, `alligator_blood`, `reset_ritual` | … | ritual |
|
||||
|
||||
### 3. REST API — complete the surface (`lyra/web/server.py`)
|
||||
|
||||
Add the missing **create/update** routes so the human UI (and any non-LLM client) can do everything:
|
||||
|
||||
- `POST /session/stack` → `log_stack(amount, note?)`; server-stamped time; returns `stack_state()`.
|
||||
- `POST /session/buyin` → `add_buyin(amount)`; returns `buy_in_total`.
|
||||
- `POST /session` → `start_session(...)`.
|
||||
- `POST /session/hand` → `log_hand(...)` (flat) and/or `record_hand(shorthand)`.
|
||||
- `PATCH /hand/{id}` → `update_hand(...)`; `DELETE /hand/{id}`.
|
||||
- `POST /session/read` → `add_read(...)`; `PATCH /read/{id}`; `DELETE` via existing entry-delete.
|
||||
- Keep existing `PATCH /session/{id}`, `DELETE /session/entry/{kind}/{id}`, `GET /session/data`.
|
||||
|
||||
All return `{ok, ...}` and a clear error on "no live session." Routes are thin wrappers over the store, mirroring the contract one-to-one.
|
||||
|
||||
### 4. Human UI — log + edit/correct
|
||||
|
||||
**Fast capture:**
|
||||
- **2nd input box** (`index.html`): slim row **below the message input, above the bottom nav icons**. Type a number → `POST /session/stack` → time-stamped, sparkline updates, a one-line confirmation drops into the **Live Log**. **No chat message, no LLM call.** Stack-only in v1. Tolerates `$685`/`685`.
|
||||
- **HUD widget** (`session.html`, in the Stack card at `:280`, mirroring `saveEdit()` at `:192`): stack field (`POST /session/stack`), buy-in field (`POST /session/buyin`), cash-out field (existing PATCH).
|
||||
|
||||
**Edit / correct (fix Lyra's mistakes):**
|
||||
- Edit any session field (exists via the PATCH edit form — verify coverage).
|
||||
- Hands list with edit + delete (`hand.html` + new PATCH/DELETE) — fix mislabeled villains, wrong board, wrong result.
|
||||
- Reads/players list with edit + delete — rename "Dave the rock" ≠ "Dave the mechanic", fix tendencies.
|
||||
- Stack entries deletable (exists via `del('stack', id)`) — verify.
|
||||
|
||||
### 5. iOS-PWA bottom safe-area fix
|
||||
|
||||
The empty band below the nav icons is a safe-area issue (likely `100vh` not accounting for `env(safe-area-inset-bottom)` / the home indicator). Fix the layout container + bottom nav CSS so the app fills the viewport with the icons seated above the home indicator. Use the `building-ios-pwas` skill at implementation time.
|
||||
|
||||
## Testing / verification
|
||||
|
||||
- **Contract conformance:** a test asserting each REST route and each `tools.py` spec matches the canonical contract (names, required args) — catches drift between the human API and the LLM API.
|
||||
- **Endpoint round-trips:** create → read → update → delete for stack, buyin, hand, read against a test session; assert rows written, time stamped, `stack_state()`/`hud()` reflect changes; assert clean error with no live session.
|
||||
- **UI manual pass:** log a stack via the 2nd box and confirm it lands in Live Log + sparkline without a chat reply; edit a hand's villain and confirm persistence; delete a bad read.
|
||||
- **PWA:** on the iOS PWA, confirm the bottom gap is gone and the 2nd input box sits above the nav with the keyboard open.
|
||||
|
||||
---
|
||||
|
||||
# Sub-project 2 — Lyra wiring *(parked)*
|
||||
|
||||
Detail preserved here; gets its own spec → plan after sub-project 1 is MVP'd.
|
||||
|
||||
## Why it exists (diagnosis from real sessions)
|
||||
|
||||
Evidence from `sess-dff2s91c` (2026-06-27 Meadows, 2026-06-28 Wheeling):
|
||||
|
||||
- **Coaching essay on every turn, including pure data** — `Stack=$685` drew 4–6 sentences of "keep that momentum rolling." (Sub-project 1's dumb capture removes these from the LLM entirely.)
|
||||
- **False tilt/fatigue reads** — "table broke, it's 11:50pm" → repeated "late-night fatigue… mental reset"; Brian: *"you seem to be reading me as tilted."* Cause: the `_route` mood nudge (`mind.py:328`) firing on non-mood messages.
|
||||
- **No bet-intent reasoning** — a value bet ($40, full house) that folded out 88 was praised as "the power of representing something stronger." It was value *lost*, not a successful rep.
|
||||
- **Eyeballs instead of `analyze_spot`** — 77 multiway got "a disciplined fold might have been better," no math, violating the persona's "never eyeball poker math" rule.
|
||||
- **Even her sharp reads leak bad logic** — the Connie read included "limp-checking in position" (contradictory).
|
||||
|
||||
Root cause: one broad per-turn card (`_CASH_CARD`, `modes.py:66`) describes traits; the model satisfies trait language with safe abstraction.
|
||||
|
||||
## Planned approach
|
||||
|
||||
- **Classifier** (`lyra/poker_classify.py`): `classify(message) -> HAND | STATUS | MENTAL | LOG | CHAT`. Heuristic v1 (card-token regex, position/street keywords, feeling phrases, time/venue), swappable for an LLM/MI50 classifier behind the same signature. Ambiguous → CHAT.
|
||||
- **Pipeline:** a `_classify` step in `mind.PIPELINE` sets `ctx.msg_type` (poker mode only); `build_messages` injects the **type fragment** in the seat now held by `mode.card` (`mind.py:152`) instead of the whole `_CASH_CARD`.
|
||||
- **Fragments** (`lyra/poker_prompts.py`, `POKER_FRAGMENTS`): concrete rules + response shape per type.
|
||||
- **HAND:** log it → `analyze_spot` if close → reason about **bet intent** (value/bluff/protection — did it work? a fold to a value bet = value lost, flag it) → name leaks (value-owning, missed value, sizing) → one opinion. No reflexive praise. Pull `player_profile` before referencing a villain. Seeded with 2 real-hand exemplars (the $40 value bet; the 77 spot).
|
||||
- **STATUS:** 1–2 sentences, no coaching, no tilt-reading.
|
||||
- **MENTAL:** full presence (already works — preserve).
|
||||
- **LOG:** one line.
|
||||
- **CHAT:** full voice, real opinion.
|
||||
- **Pipeline fixes:** kill the misfiring `_route` mood nudge (`mind.py:328`); trim the always-on mode-menu note (`mind.py:77`) in poker mode.
|
||||
- **MI50 tool-calling:** enable tools on the MI50 backend (`chat.py` `TOOL_BACKENDS = {"cloud"}` at `:21`) so a fine-tuned, tool-calling poker model can drive the contract. Requires the fine-tune to emit the contract's tool-call format.
|
||||
|
||||
## HAND exemplars (preserved for sub-project 2)
|
||||
|
||||
> *Brian:* "Flopped bottom set with 22, turned a full house, bet $40 on the river, he folded 88."
|
||||
> *Lyra:* "That's a value bet that got no value — 88 was never folding to a smaller stab. $40 into that pot was too much; ~$20–25 gets called by the over-pair and worse two-pairs. The hand's a monster, the leak is the sizing."
|
||||
|
||||
> *Brian:* "77 multiway, flop 4h5c3c, HJ bets 75, BTN shoves 74, I call. Turn/river check through, HJ wins with 64."
|
||||
> *Lyra:* "Against a bet and a shove on 4-5-3 you're drawing thin — sets, two pair, and the made wheel are all ahead, and you block almost none of it. The stack-depth read (he only had ~150 behind) is real, but that's a reason to fold and wait, not to call off light. This is the value-owning spot you flagged yourself."
|
||||
@@ -1,117 +0,0 @@
|
||||
# Poker message-type prompts (sub-project 2)
|
||||
|
||||
- **Date:** 2026-07-01
|
||||
- **Status:** Spec for review
|
||||
- **Branch:** `feat/poker-mode-prompts` (continues on the same branch; sub-project 1 shipped there)
|
||||
- **Supersedes:** the parked "sub-project 2" section of `docs/superpowers/specs/2026-06-28-poker-mode-prompts-design.md`
|
||||
|
||||
## Problem (recap)
|
||||
|
||||
In poker mode Lyra routes correctly but her replies are generic — one broad `_CASH_CARD` (`lyra/modes.py:66-116`) describes *traits* and gets injected on every turn, so the model satisfies it with safe, flattering abstraction. From real sessions: coaching essays on bare stack updates, false tilt/fatigue reads on neutral logistics ("table broke, it's 11:50pm" → "late-night fatigue…"), praising a value bet that got *no* value, and hedging ("a disciplined fold might have been better") instead of calling `analyze_spot`.
|
||||
|
||||
The fix: stop sending one card for every message. Detect *what kind of message* Brian just sent and inject a small, concrete response contract for that type.
|
||||
|
||||
## Goals
|
||||
|
||||
1. A per-turn **message-type classifier** for poker mode, and **per-type prompt fragments** replacing the monolithic card.
|
||||
2. Kill the two pipeline sources of mush in poker mode: the misfiring mood nudge and the always-on mode-menu note.
|
||||
3. Make HAND turns reason about **bet intent** and lean on `analyze_spot` (NLH only).
|
||||
4. Keep the door open for a fine-tuned MI50 classifier/model behind the same seams.
|
||||
|
||||
## Non-goals
|
||||
|
||||
- PLO/Omaha strategic analysis. `record_hand` already parses 4-card hands and the replayer renders them; only `analyze_spot` (equity) is NLH-bound. **This pass: PLO hands are logged/replayed but get no NLH-style analysis.**
|
||||
- A PLO equity engine.
|
||||
- Changing the store, the REST API, or the tools (sub-project 1, done).
|
||||
- An LLM classifier in v1 (heuristic first; the function is the swappable seam).
|
||||
|
||||
## Build order (confirmed)
|
||||
|
||||
**Phase A — pipeline fixes** (quick win) → **Phase B — classifier + fragments** (the meat) → **Phase C — MI50 tool-calling** (separable).
|
||||
|
||||
---
|
||||
|
||||
## Phase A — Pipeline fixes
|
||||
|
||||
Both are independent of the classifier and immediately reduce mush in poker mode.
|
||||
|
||||
1. **Suppress the mode-menu note in poker mode.** `_mode_menu_note` (`mind.py:77-88`) is injected every turn (`mind.py:158`). At the table she should not be offering to switch modes. In `build_messages`, skip that append when `mode.key == "poker_cash"`.
|
||||
2. **Suppress the `_route` mood nudge in poker mode.** `_route` (`mind.py:320-339`) sets `ctx.register` + a "steady/hype" note from a lexicon heuristic; in poker this double-signals with the card and caused the false tilt reads. In `_route`, when `mode.key == "poker_cash"`, resolve the mode as normal (line 324 stays) but **skip the register/note block** (327-338). Poker register comes from the Phase B fragments (esp. MENTAL) instead. Non-poker modes keep the nudge unchanged.
|
||||
|
||||
## Phase B — Classifier + per-type fragments
|
||||
|
||||
### New module `lyra/poker_prompts.py`
|
||||
|
||||
Cohesive home for poker prompting: the classifier, a lean always-on base, and the per-type fragments.
|
||||
|
||||
```
|
||||
classify(user_msg: str) -> str # "HAND" | "STATUS" | "MENTAL" | "LOG" | "CHAT"
|
||||
BASE: str # always-on poker rules (logging, session_state, rituals, equity)
|
||||
FRAGMENTS: dict[str, str] # msg_type -> response-shape contract
|
||||
fragment_for(msg_type: str | None) -> str # FRAGMENTS.get(msg_type, FRAGMENTS["CHAT"])
|
||||
```
|
||||
|
||||
`classify` is a **pure function** (no DB), unit-tested like `perceive.read`. Heuristic signals, first match wins in priority order:
|
||||
|
||||
1. **HAND** — card tokens (regex `\b[2-9TJQKA][shdc]\b`, ≥2), or position tokens (UTG/MP/HJ/CO/BTN/SB/BB/"button"/"hijack"/"straddle"), or a street word (flop/turn/river) with a betting verb (bet/raise/call/fold/check/shove/limp/jam).
|
||||
2. **MENTAL** — first-person feeling: "I feel", "I'm tilted/steaming/fried/tired/frustrated/confident/stuck/bored", "on tilt", "in my head", "mental", "leak".
|
||||
3. **STATUS** — logistics with no cards: "table broke", "new table", "waiting for a seat", "seat opened", "just sat", clock times, "heading to"/venue mentions.
|
||||
4. **LOG** — bare money/result prose that slipped past the quick-capture box: "I'm at", "stack is", "down to", "up to", "out for", "cashed", "rebought", "rebuy" with a number.
|
||||
5. **CHAT** — default fallback (questions, open talk).
|
||||
|
||||
(HAND wins over MENTAL so a described hand still gets logged even if he's venting; the HAND fragment tells her to acknowledge the feeling too.)
|
||||
|
||||
### Injection (`mind.py`)
|
||||
|
||||
- Add `msg_type: str | None = None` to `TurnContext` (`mind.py:305`).
|
||||
- In `_route`, when `mode.key == "poker_cash"`, set `ctx.msg_type = poker_prompts.classify(ctx.user_msg)`.
|
||||
- Thread it through `_compose` → add a `msg_type` param to `build_messages` (`mind.py:137`, `344`).
|
||||
- Replace the card-injection block (`mind.py:152-154`) with:
|
||||
```python
|
||||
if mode and mode.key == "poker_cash":
|
||||
messages.append({"role": "system", "content": poker_prompts.BASE})
|
||||
messages.append({"role": "system", "content": poker_prompts.fragment_for(msg_type)})
|
||||
elif mode and mode.card:
|
||||
messages.append({"role": "system", "content": mode.card})
|
||||
```
|
||||
- Set `CASH.card = ""` in `modes.py` (content moves to `poker_prompts`; keep `_CASH_CARD` text as the source material to distill from, then delete once fragments are in). `CASH.tools` is unchanged.
|
||||
|
||||
### The fragments (concrete contracts, not traits)
|
||||
|
||||
**BASE** (always-on in poker) — distilled from the card's cross-cutting rules: log any trackable fact FIRST then reply (stack→`log_stack`, hand→`record_hand`, read→`add_read`, rebuy→`add_buyin`); for any equity/who's-ahead question call `analyze_spot`, never eyeball; when he asks where he's at (stack/net/gator), call `session_state` and answer from it; rituals (`scar_note`/`confidence_bank`/`alligator_blood`/`reset_ritual`) — run them in his language, honest punt-vs-cooler line, never invent one.
|
||||
|
||||
**HAND** — Log it (`record_hand`). Then **if it's NLH**: reason about **bet intent** — for each meaningful bet name what it was for (value / bluff / protection) and whether it worked (*a fold to a value bet = value left behind — flag it; a call of a bluff = it failed*); call `analyze_spot` for a close equity/who's-ahead spot; name leaks plainly (value-owning, missed value, sizing); give ONE real opinion. **No reflexive praise** — don't open with "nice hand." If a named villain is referenced, call `player_profile` first — never invent a read. **If it's PLO/Omaha or any non-NLH game**, just confirm it's logged and offer at most a light read; do NOT attempt NLH-style equity or deep analysis. Talk in prose, not a listicle. Seeded with 2 real-hand exemplars:
|
||||
|
||||
> *Brian:* "Flopped bottom set with 22, turned a full house, bet $40 on the river, he folded 88."
|
||||
> *Lyra:* "That's a value bet that got no value — 88 was never folding to a smaller stab. $40 into that pot was too much; ~$20–25 gets called by the over-pair and worse two-pairs. The hand's a monster, the leak is the sizing."
|
||||
|
||||
> *Brian:* "77 multiway, flop 4h5c3c, HJ bets 75, BTN shoves 74, I call. Turn/river check through, HJ wins with 64."
|
||||
> *Lyra:* "Against a bet and a shove on 4-5-3 you're drawing thin — sets, two pair, and the made wheel are all ahead, and you block almost none of it. The stack-depth read (he only had ~150 behind) is real, but that's a reason to fold and wait, not to call off light. This is the value-owning spot you flagged yourself."
|
||||
|
||||
**STATUS** — He's narrating logistics (time, venue, table change, waiting for a seat). Acknowledge in 1–2 sentences, log a stack only if a bare number is present, then stop. **No coaching, no strategy dump, and do NOT read him as tilted/tired/impatient — a neutral update is not a mood.**
|
||||
|
||||
**MENTAL** — He told you how he's feeling. This is when he needs you most. Drop the shorthand, full presence, real voice — talk him down off tilt, hold him disciplined through a card-dead stretch, engage the mental game honestly. Never a clipped confirmation.
|
||||
|
||||
**LOG** — He handed you a bare fact (stack/result/buyin) that isn't already captured. Log it, confirm in ONE short line ("$317 logged."), stop. No coaching.
|
||||
|
||||
**CHAT** — Open talk or a question that isn't a specific hand. Your real voice, an actual opinion, no filler sign-offs. If it's a concrete strategy spot, engage it for real (call `analyze_spot` when there are cards).
|
||||
|
||||
## Phase C — MI50 tool-calling
|
||||
|
||||
Flip `TOOL_BACKENDS = {"cloud"}` → `{"cloud", "mi50"}` (`chat.py:21`). Precondition: the MI50's llama.cpp server must be launched with `--jinja` (per the existing comment) or tool calls 500. This lets a tool-calling model on the MI50 drive the same contract from sub-project 1. If a tool ever needs `msg_type`, add it to the dispatch dict (`chat.py:100`/`128`) — the pipeline `TurnContext` does not currently flow into the tool loop. Ship this only once the MI50 backend is `--jinja`-enabled and a tool-capable model is loaded.
|
||||
|
||||
## Testing
|
||||
|
||||
- **`classify` unit tests** (pure, no DB — mirror `test_perceive.py` top): real messages from the transcripts →
|
||||
`"Button straddle on. I limp UTG with 22. Flop 2d7cjh…"` → `HAND`;
|
||||
`"table broke, it's 11:50pm"` → `STATUS`;
|
||||
`"I feel like I'm being mean when I raise"` → `MENTAL`;
|
||||
`"I'm at 317 now"` → `LOG`;
|
||||
`"should I have folded the river?"` → `CHAT` (no cards) — or `HAND` if cards present.
|
||||
- **`build_messages` fragment injection** (blob-join pattern from `test_chat.py:57-70`): in poker mode, a HAND message includes the HAND fragment string and NOT the STATUS one; a STATUS message includes STATUS and NOT HAND; assert `poker_prompts.BASE` is always present in poker mode.
|
||||
- **Pipeline fixes**: `assemble` in poker mode on a tilt-lexicon message → `turn.register is None` and no tilt note in the system blob (nudge suppressed); the mode-menu note string is absent in poker mode and present in a non-poker mode.
|
||||
- **No regressions**: full suite green (currently 123).
|
||||
|
||||
## Rollout
|
||||
|
||||
Phase A and Phase B ship together as the meaningful behavior change (A alone leaves the card in place). Phase C waits on the MI50 `--jinja` flag. Verify live in a real/replayed session before merging the branch.
|
||||
@@ -1,79 +0,0 @@
|
||||
# MI50 runaway guards: dream-cycle budget + host watchdog
|
||||
|
||||
**Date:** 2026-07-04
|
||||
**Branch:** `fix/mi50-summary-cap-fallback`
|
||||
**Follows:** the summary cap/fallback fix (same branch). This adds general
|
||||
"never run unchecked again" protection on top of the specific summary fix.
|
||||
|
||||
## Problem
|
||||
|
||||
The summary fix stops the *known* runaway (uncapped summaries). But the operator
|
||||
wants a guarantee that *no* cause — known or future — can peg the MI50 for hours
|
||||
unattended. Two independent layers, per operator decision:
|
||||
|
||||
- **C (in-app, primary):** Lyra's own dream cycle bounds itself.
|
||||
- **A (host, fallback):** a watchdog on the always-on Proxmox host kills the
|
||||
backend if the GPU runs too long or too hot, regardless of cause. Trips only
|
||||
after **1 hr** of continuous busy so legitimate manual workloads (~40 min) run
|
||||
untouched.
|
||||
|
||||
## Design
|
||||
|
||||
### C — dream-cycle time budget (`lyra/`)
|
||||
|
||||
1. **Per-call ceiling.** `llm.complete()` currently sets a timeout only when one
|
||||
is passed; otherwise it inherits the OpenAI SDK default (600s × 2 retries ≈
|
||||
30 min). Change the default: when no `timeout` is given, the cloud/mi50 paths
|
||||
use **300s + `max_retries=0`**. This bounds *every* consolidation/introspection
|
||||
call (`profile`, `era`, `narrative`, `reflect`, `think`) — not just summaries —
|
||||
with one change. Live chat uses `chat_call*`, a different path, unaffected.
|
||||
|
||||
2. **Cycle deadline.** `dream_cycle()` sets `deadline = now + DREAM_CYCLE_BUDGET`
|
||||
(**20 min**) before its heavy stages and checks it between them (continuity →
|
||||
coherence → curiosity). Once past the deadline, remaining stages are skipped,
|
||||
the cycle logs `dream cycle over budget — stopped early`, appends a
|
||||
`stopped early (over budget)` action, and `notify.push()` pings Brian. A hung
|
||||
single call can't blow past ~300s (step 1), so the between-stage checks keep a
|
||||
pass bounded to roughly the budget.
|
||||
|
||||
### A — host watchdog (`deploy/mi50-watchdog/`)
|
||||
|
||||
A bash script + systemd timer installed on the Proxmox host (`10.0.0.4`), which
|
||||
has `rocm-smi` + `docker` and is always on. Runs every 2 min:
|
||||
|
||||
- **Duration rule:** track continuous busy time in a state file (`GPU use % > 0`).
|
||||
If busy ≥ **3600s** straight → `docker stop lyra-brain`. Idle clears the timer,
|
||||
so a 40-min job never trips it.
|
||||
- **Temp rule (independent):** if junction ≥ **97°C** for **3 consecutive checks
|
||||
(~6 min)** → stop. A normal-temp long workload won't trip this; only a genuinely
|
||||
overheating one.
|
||||
- On either trip: stop the container, clear state, `logger` a line, and POST to
|
||||
the ntfy topic so Brian is told. Thresholds are unit-file env vars (tunable).
|
||||
|
||||
Files: `mi50-watchdog.sh`, `mi50-watchdog.service`, `mi50-watchdog.timer`,
|
||||
`README.md` (install: copy to host, set ntfy env, `systemctl enable --now`).
|
||||
|
||||
## Testing
|
||||
|
||||
- **C step 1:** `llm.complete()` with no timeout builds the client with
|
||||
`timeout=300, max_retries=0` and still no `max_tokens` (update existing
|
||||
`test_llm_bounds` default test).
|
||||
- **C step 2:** a dream pass that goes over budget skips later stages, records the
|
||||
`stopped early` action, and calls `notify.push` (stub the clock/operations in
|
||||
`test_dream`).
|
||||
- **A:** decision logic dry-run locally against sample `rocm-smi` output (busy /
|
||||
idle / hot). Cannot be live-verified now (card is off, operator away) — install
|
||||
+ real trip test deferred to when the card is back.
|
||||
|
||||
## Verification
|
||||
|
||||
C is repo code and ships live the moment `lyra-dream` restarts. A is staged in the
|
||||
repo for host install; verify on the host when the card returns (force a long/hot
|
||||
condition or lower thresholds temporarily and confirm it stops the container +
|
||||
pings).
|
||||
|
||||
## Out of scope (YAGNI)
|
||||
|
||||
- No power cap (option B) — deferred; C+A cover the "unchecked" concern and the
|
||||
electricity cost of one event is trivial (~$0.10).
|
||||
- No change to live chat, `chat_call*`, or `config.summary_backend`.
|
||||
@@ -1,115 +0,0 @@
|
||||
# Bounded MI50 summaries with cloud fallback
|
||||
|
||||
**Date:** 2026-07-04
|
||||
**Branch:** `fix/mi50-summary-cap-fallback`
|
||||
|
||||
## Problem
|
||||
|
||||
The dream cycle's `summarize_all` runs against the MI50 (`backend=mi50`). Each
|
||||
summary call to `llm.complete()` on the `mi50` path hands the OpenAI SDK **no
|
||||
`max_tokens` and no timeout**, so it inherits SDK defaults — a 600s request
|
||||
timeout with 2 internal retries, i.e. **~30 minutes per call before it raises
|
||||
"Request timed out."** On top of that, `summary.py` had its own 4-attempt retry
|
||||
loop, so a single unsummarizable session could keep the GPU pegged for hours.
|
||||
|
||||
Observed live (2026-07-04, ~01:00–02:00): the dream service looped
|
||||
`summarize-all … backend=mi50` since 23:02, every call timing out, nothing
|
||||
written to the DB since 00:56, the MI50 generating **7,000–8,000-token**
|
||||
completions (a gist needs <200), all four llama.cpp slots busy, fans blaring.
|
||||
|
||||
This is **not** context overflow — the server log showed `context shift = 0`,
|
||||
`truncated = 1 = 0`. The prompts are small (~900–1,500 tokens). The failure is
|
||||
purely **unbounded generation length on a slow backend → timeout → retry loop.**
|
||||
|
||||
## Goals
|
||||
|
||||
- Keep the MI50 as the primary summary backend (Brian's preference, gaming-safe).
|
||||
- Cap each summary generation so it finishes fast and can never run away.
|
||||
- Make a stuck MI50 call **fail fast** and fall back to cloud, instead of looping
|
||||
all night.
|
||||
- Change nothing about live chat, reflect, or think.
|
||||
|
||||
## Design
|
||||
|
||||
### 1. `lyra/llm.py` — `complete()` gains two optional params
|
||||
|
||||
```
|
||||
def complete(messages, backend="local", model=None,
|
||||
max_tokens: int | None = None, timeout: float | None = None) -> str
|
||||
```
|
||||
|
||||
- `max_tokens` (when set): passed to the create() call —
|
||||
`max_tokens=` for the `cloud`/`mi50` OpenAI paths, `options={"num_predict": …}`
|
||||
for the `local` Ollama path.
|
||||
- `timeout` (when set): for the `cloud`/`mi50` OpenAI clients, build the client
|
||||
with `timeout=<t>, max_retries=0` so the call bails quickly and *we* own the
|
||||
retry policy (eliminates the hidden 3×600s). For `local`, use it as the httpx
|
||||
timeout.
|
||||
- Both default to `None` → **behavior identical to today** for every other
|
||||
caller (chat_call, reflect, think, etc.). Backward compatible.
|
||||
|
||||
### 2. `lyra/summary.py` — capped, fast-fail, cloud fallback
|
||||
|
||||
Constants:
|
||||
|
||||
```
|
||||
SUMMARY_MAX_TOKENS = 768 # ~3× the longest real gist; bounds gen to ~1 min on MI50
|
||||
MI50_ATTEMPTS = 2 # attempts on the primary backend before falling back
|
||||
SUMMARY_TIMEOUT = 150 # seconds/call — capped 768-tok gist finishes in ~60-90s
|
||||
```
|
||||
|
||||
Rewrite `_summarize_text(text, backend)`:
|
||||
|
||||
1. Try `backend` up to `MI50_ATTEMPTS` times, each:
|
||||
`llm.complete(messages, backend=backend, max_tokens=SUMMARY_MAX_TOKENS, timeout=SUMMARY_TIMEOUT)`,
|
||||
with a short backoff between attempts.
|
||||
2. If all primary attempts fail **and** `backend != "cloud"` **and** an OpenAI
|
||||
key is configured → one final cloud attempt (same cap/timeout), logged as
|
||||
`summary fell back to cloud`.
|
||||
3. If cloud also fails or is unavailable → raise.
|
||||
|
||||
Fallback is per-`_summarize_text` call (i.e. per chunk), so the long-session
|
||||
chunk/merge path in `_summarize_transcript` is unaffected. The old `_RETRIES = 4`
|
||||
loop is replaced by this structure.
|
||||
|
||||
### 3. Degenerate-output guard (added 2026-07-04)
|
||||
|
||||
A wedged local backend — observed live when the MI50 overheated to 99°C junction —
|
||||
returns a single character repeated (`"?????"`) as a *successful* 200 response,
|
||||
which neither the timeout nor the exception path catches. So each `_call()`
|
||||
validates its output: `_looks_degenerate(text)` flags output (≥24 non-space chars)
|
||||
whose most-common non-whitespace character exceeds 50% of the text, and raises
|
||||
`DegenerateOutput` — which the retry/fallback loop treats exactly like any other
|
||||
failure (retry the primary, then fall back to cloud). Real gists are diverse prose
|
||||
(top char well under 20%), so the threshold won't false-positive; short outputs are
|
||||
exempt. If cloud *also* returns junk, it raises and stops — no infinite loop.
|
||||
|
||||
## Testing
|
||||
|
||||
Unit (pytest, `tests/test_summary_fallback.py`), monkeypatching `llm.complete`:
|
||||
|
||||
- Fallback fires: `mi50` raises on every call → after `MI50_ATTEMPTS` the cloud
|
||||
attempt runs and its result is returned; a `fell back to cloud` log is emitted.
|
||||
- No fallback when primary is already `cloud` (retries, then raises).
|
||||
- No fallback when no OpenAI key (raises after primary attempts).
|
||||
- `max_tokens` and `timeout` are threaded into every `complete()` call.
|
||||
|
||||
Plus a light `llm.complete` test that `max_tokens`/`timeout` reach the client
|
||||
kwargs (monkeypatch the OpenAI client).
|
||||
|
||||
## Verification (real)
|
||||
|
||||
After deploy (`systemctl --user restart lyra-dream lyra-web` — editable install):
|
||||
watch `journalctl --user -fu lyra-dream` through a summarize cycle and confirm
|
||||
`llm done … out≈768` completing in ~1 min, an actual `summarized session` row
|
||||
written (DB summary count rises), and **no** "Request timed out". Confirm the
|
||||
llama.cpp slot shows bounded `n_decoded ≈ 768`.
|
||||
|
||||
## Out of scope (YAGNI)
|
||||
|
||||
- The degenerate-output guard (§3) targets the *observed* failure — one char
|
||||
repeated. It does not try to detect subtler degeneration (repeated phrases,
|
||||
off-topic rambling); that's fuzzy and unmotivated until seen.
|
||||
- No change to `chat_call`/reflect/think or `config.summary_backend`.
|
||||
- No change to profile/era/narrative rebuild calls (separate, and not the loop
|
||||
culprit); can adopt the same `max_tokens` later if they show the same rambling.
|
||||
+2
-9
@@ -69,7 +69,6 @@ def _mind_loop(messages, backend: Backend, model: str | None, tool_specs,
|
||||
messages.append(assistant_msg)
|
||||
for tc in tool_calls:
|
||||
result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
|
||||
memory.add_tool_event(session_id, tc["name"], tc["arguments"], result)
|
||||
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"])
|
||||
@@ -100,9 +99,6 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
|
||||
tool_specs = toolkit.specs(turn.mode.tools) if backend in TOOL_BACKENDS else None
|
||||
ctx = {"session_id": session_id, "backend": backend}
|
||||
|
||||
# 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, _ = _mind_loop(messages, backend, model, tool_specs, ctx, session_id)
|
||||
mouth = _mouth_target(cfg, backend, model)
|
||||
if mouth and reply:
|
||||
@@ -111,6 +107,7 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
|
||||
reply = _TANGLED
|
||||
logbus.log("info", "reply", session=session_id, chars=len(reply), voiced=bool(mouth))
|
||||
|
||||
memory.remember(session_id, "user", user_msg)
|
||||
memory.remember(session_id, "assistant", reply)
|
||||
summary.maybe_summarize_async(session_id) # compact once enough new turns pile up
|
||||
return reply
|
||||
@@ -131,10 +128,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
|
||||
ctx = {"session_id": session_id, "backend": backend}
|
||||
mouth = _mouth_target(cfg, backend, model)
|
||||
|
||||
# Persist the user turn up front (see respond): keeps tool events, which fire
|
||||
# mid-turn, chronologically after the user message in the exported transcript.
|
||||
memory.remember(session_id, "user", user_msg)
|
||||
|
||||
if mouth is None:
|
||||
# No separate voice: stream the mind directly (the original path, unchanged).
|
||||
parts: list[str] = []
|
||||
@@ -156,7 +149,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
|
||||
messages.append(assistant_msg)
|
||||
for tc in tool_calls:
|
||||
result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
|
||||
memory.add_tool_event(session_id, tc["name"], tc["arguments"], result)
|
||||
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"])
|
||||
@@ -185,6 +177,7 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
|
||||
yield ("delta", reply)
|
||||
|
||||
logbus.log("info", "reply", session=session_id, chars=len(reply), voiced=bool(mouth))
|
||||
memory.remember(session_id, "user", user_msg)
|
||||
memory.remember(session_id, "assistant", reply)
|
||||
summary.maybe_summarize_async(session_id)
|
||||
yield ("done", reply)
|
||||
|
||||
+2
-21
@@ -9,39 +9,20 @@ a long silence *means* to her is left to her own reflection, not prescribed here
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import datetime, timezone
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from lyra import config
|
||||
|
||||
|
||||
def now() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def _local_tz() -> ZoneInfo | timezone:
|
||||
"""Brian's configured local zone (falls back to UTC if it can't be loaded)."""
|
||||
try:
|
||||
return ZoneInfo(config.load().timezone)
|
||||
except Exception:
|
||||
return timezone.utc
|
||||
|
||||
|
||||
def _parse(iso: str) -> datetime:
|
||||
dt = datetime.fromisoformat(iso)
|
||||
return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
|
||||
|
||||
|
||||
def short(iso_or_dt: str | datetime | None = None) -> str:
|
||||
"""Local time-of-day like '10:45pm', for timeline rows."""
|
||||
dt = _parse(iso_or_dt) if isinstance(iso_or_dt, str) else (iso_or_dt or now())
|
||||
return dt.astimezone(_local_tz()).strftime("%-I:%M%p").lower()
|
||||
|
||||
|
||||
def stamp(dt: datetime | None = None) -> str:
|
||||
"""Wall-clock stamp in Brian's local timezone, e.g.
|
||||
'Friday, 27 Jun 2026, 01:50 EDT'. Times are stored UTC; this is what she *reads*,
|
||||
so 'what time is it' answers in his time, not UTC."""
|
||||
return (dt or now()).astimezone(_local_tz()).strftime("%A, %d %b %Y, %H:%M %Z")
|
||||
"""Wall-clock stamp, e.g. 'Wednesday, 17 Jun 2026, 01:50 UTC'."""
|
||||
return (dt or now()).strftime("%A, %d %b %Y, %H:%M UTC")
|
||||
|
||||
|
||||
def gap_seconds(since_iso: str | None, ref: datetime | None = None) -> float | None:
|
||||
|
||||
+4
-40
@@ -25,27 +25,13 @@ import argparse
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from lyra import (
|
||||
config, era, feeds, logbus, memory, narrative, notify, poker, profile, self_state,
|
||||
summary, thoughts,
|
||||
)
|
||||
from lyra import config, era, feeds, logbus, memory, narrative, profile, self_state, summary, thoughts
|
||||
from lyra.llm import Backend
|
||||
from lyra.summary import SUMMARIZE_AFTER
|
||||
|
||||
# A drive at/above this has built up enough to act on.
|
||||
THRESHOLD = 0.6
|
||||
|
||||
# Wall-clock ceiling for a single pass. Every consolidation/introspection call is
|
||||
# individually bounded (llm.complete's default timeout), but this caps the whole
|
||||
# pass: once exceeded, remaining stages are skipped and Brian is pinged — so a slow
|
||||
# or wedged MI50 can never grind for hours unattended. The host watchdog (A) is the
|
||||
# independent fallback if this ever fails to fire.
|
||||
DREAM_CYCLE_BUDGET_SEC = 20 * 60
|
||||
|
||||
|
||||
def _over_budget(deadline: float) -> bool:
|
||||
return time.monotonic() > deadline
|
||||
|
||||
# How much backlog saturates each pressure (the drive reaches ~1.0 at this level).
|
||||
CONTINUITY_FULL = 4 # ripe (summary-needing) sessions
|
||||
COHERENCE_FULL = 10 # gists not yet folded into the profile
|
||||
@@ -108,12 +94,9 @@ def dream_cycle(backend: Backend | None = None, force: bool = False) -> dict:
|
||||
logbus.log("error", "daily digest failed", error=str(exc)[:160])
|
||||
|
||||
actions: list[str] = []
|
||||
# Cap the whole pass: skip any stage we reach after the deadline (checked
|
||||
# between stages; each call is already individually bounded).
|
||||
deadline = time.monotonic() + DREAM_CYCLE_BUDGET_SEC
|
||||
|
||||
# --- continuity: compact raw sessions into gists ---
|
||||
if (force or drives["continuity"] >= THRESHOLD) and not _over_budget(deadline):
|
||||
if force or drives["continuity"] >= THRESHOLD:
|
||||
report = summary.summarize_all(backend=backend)
|
||||
actions.append(f"consolidated {report['summarized']} sessions")
|
||||
drives["continuity"] = 0.0
|
||||
@@ -123,23 +106,15 @@ def dream_cycle(backend: Backend | None = None, force: bool = False) -> dict:
|
||||
drives["coherence"] = _clamp(profile_lag / COHERENCE_FULL)
|
||||
|
||||
# --- coherence: fold gists up into profile / eras / narrative ---
|
||||
if (force or drives["coherence"] >= THRESHOLD) and not _over_budget(deadline):
|
||||
if force or drives["coherence"] >= THRESHOLD:
|
||||
profile.rebuild_profile(backend=backend)
|
||||
era.rebuild_eras(backend=backend)
|
||||
narrative.rebuild_narrative(backend=backend)
|
||||
actions.append("integrated knowledge (profile/eras/narrative)")
|
||||
drives["coherence"] = 0.0
|
||||
# Off-hot-path villain identity housekeeping: propose likely same-person
|
||||
# merges for Brian to confirm on the Players page. Never sinks the cycle.
|
||||
try:
|
||||
filed = poker.scan_merge_candidates()
|
||||
if filed:
|
||||
actions.append(f"flagged {filed} possible villain merge(s)")
|
||||
except Exception as exc:
|
||||
logbus.log("error", "villain merge scan failed", error=str(exc)[:200])
|
||||
|
||||
# --- curiosity: reflect and evolve the self, then advance the thought loop ---
|
||||
if (force or drives["curiosity"] >= THRESHOLD) and not _over_budget(deadline):
|
||||
if force or drives["curiosity"] >= THRESHOLD:
|
||||
# reflect()/think() self-resolve to the *introspection* backend (her voice),
|
||||
# which can differ from the consolidation backend above — don't pass `backend`.
|
||||
self_state.reflect(source="dream") # writes state + journal itself
|
||||
@@ -154,17 +129,6 @@ def dream_cycle(backend: Backend | None = None, force: bool = False) -> dict:
|
||||
logbus.log("error", "thought loop failed", error=str(exc)[:200])
|
||||
drives["curiosity"] = CURIOSITY_FLOOR
|
||||
|
||||
if _over_budget(deadline):
|
||||
logbus.log("error", "dream cycle over budget — stopped early",
|
||||
budget_min=DREAM_CYCLE_BUDGET_SEC // 60, done=actions)
|
||||
actions.append("stopped early (over budget)")
|
||||
notify.push(
|
||||
"Lyra — dream cycle over budget",
|
||||
f"A dream pass ran past {DREAM_CYCLE_BUDGET_SEC // 60} min and stopped early. "
|
||||
"The MI50 backend may be slow or wedged — worth a look.",
|
||||
tags="warning",
|
||||
)
|
||||
|
||||
if not actions:
|
||||
actions.append("rested (nothing past threshold)")
|
||||
|
||||
|
||||
+20
-78
@@ -2,13 +2,11 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import time
|
||||
from typing import Iterator, Literal, TypedDict
|
||||
|
||||
import httpx
|
||||
from openai import OpenAI
|
||||
|
||||
from lyra import logbus
|
||||
from lyra.config import load
|
||||
|
||||
|
||||
@@ -19,77 +17,31 @@ class Message(TypedDict):
|
||||
|
||||
Backend = Literal["local", "cloud", "mi50"]
|
||||
|
||||
# Hard ceiling on any single completion so a slow/stuck backend can't hang a call
|
||||
# for the SDK's 600s x2-retry default (~30 min). Callers pass an explicit timeout
|
||||
# to override (e.g. summary.py's tighter fast-fail).
|
||||
_DEFAULT_TIMEOUT = 300.0
|
||||
|
||||
|
||||
def _approx_tok(messages: list) -> int:
|
||||
"""Rough prompt size (chars/4) — enough to see what's loading a backend."""
|
||||
total = 0
|
||||
for m in messages or []:
|
||||
if isinstance(m, dict) and isinstance(m.get("content"), str):
|
||||
total += len(m["content"])
|
||||
return total // 4
|
||||
|
||||
|
||||
def _resolved_model(cfg, backend: Backend, model: str | None) -> str:
|
||||
if backend == "cloud":
|
||||
return model or cfg.cloud_model
|
||||
if backend == "mi50":
|
||||
return model or cfg.mi50_model
|
||||
return model or cfg.local_model
|
||||
|
||||
|
||||
def complete(messages: list[Message], backend: Backend = "local", model: str | None = None,
|
||||
max_tokens: int | None = None, timeout: float | None = None) -> str:
|
||||
def complete(messages: list[Message], backend: Backend = "local", model: str | None = None) -> str:
|
||||
"""Generate a completion. `model` overrides the backend's default model
|
||||
(used so live chat can run a stronger cloud model than bulk consolidation).
|
||||
|
||||
`max_tokens` caps the generation length (guards a slow local model against
|
||||
rambling for thousands of tokens). `timeout`, when set, bounds each request
|
||||
and disables the SDK's own retries so the caller owns retry/fallback policy.
|
||||
Both default to None → unchanged behavior for every existing caller."""
|
||||
(used so live chat can run a stronger cloud model than bulk consolidation)."""
|
||||
cfg = load()
|
||||
mdl = _resolved_model(cfg, backend, model)
|
||||
logbus.log("info", "llm call", kind="complete", backend=backend, model=mdl, tok=_approx_tok(messages))
|
||||
t0 = time.monotonic()
|
||||
if backend == "cloud":
|
||||
if not cfg.openai_api_key:
|
||||
raise RuntimeError("OPENAI_API_KEY is not set")
|
||||
client = OpenAI(api_key=cfg.openai_api_key)
|
||||
resp = client.chat.completions.create(model=model or cfg.cloud_model, messages=messages)
|
||||
return resp.choices[0].message.content or ""
|
||||
|
||||
if backend in ("cloud", "mi50"):
|
||||
if backend == "cloud":
|
||||
if not cfg.openai_api_key:
|
||||
raise RuntimeError("OPENAI_API_KEY is not set")
|
||||
client_kwargs: dict = {"api_key": cfg.openai_api_key}
|
||||
else:
|
||||
# MI50 box runs an OpenAI-compatible llama.cpp server; key is unused.
|
||||
client_kwargs = {"api_key": "not-needed", "base_url": cfg.mi50_base_url}
|
||||
# Always bound the request: default 300s (vs the SDK's 600s x2 retries ≈
|
||||
# 30 min that let a stuck MI50 call hang for half an hour), and disable the
|
||||
# SDK's own retries so the caller owns retry/fallback policy.
|
||||
client_kwargs["timeout"] = timeout if timeout is not None else _DEFAULT_TIMEOUT
|
||||
client_kwargs["max_retries"] = 0
|
||||
client = OpenAI(**client_kwargs)
|
||||
create_kwargs: dict = {"model": mdl, "messages": messages}
|
||||
if max_tokens is not None:
|
||||
create_kwargs["max_tokens"] = max_tokens
|
||||
resp = client.chat.completions.create(**create_kwargs)
|
||||
out = resp.choices[0].message.content or ""
|
||||
else:
|
||||
payload: dict = {"model": mdl, "messages": messages, "stream": False}
|
||||
if max_tokens is not None:
|
||||
payload["options"] = {"num_predict": max_tokens}
|
||||
resp = httpx.post(
|
||||
f"{cfg.local_base_url}/api/chat",
|
||||
json=payload,
|
||||
timeout=timeout or 120,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
out = resp.json()["message"]["content"]
|
||||
if backend == "mi50":
|
||||
# MI50 box runs an OpenAI-compatible llama.cpp server; key is unused.
|
||||
client = OpenAI(api_key="not-needed", base_url=cfg.mi50_base_url)
|
||||
resp = client.chat.completions.create(model=model or cfg.mi50_model, messages=messages)
|
||||
return resp.choices[0].message.content or ""
|
||||
|
||||
logbus.log("info", "llm done", kind="complete", backend=backend,
|
||||
ms=int((time.monotonic() - t0) * 1000), out=len(out))
|
||||
return out
|
||||
resp = httpx.post(
|
||||
f"{cfg.local_base_url}/api/chat",
|
||||
json={"model": model or cfg.local_model, "messages": messages, "stream": False},
|
||||
timeout=120,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
return resp.json()["message"]["content"]
|
||||
|
||||
|
||||
def chat_call(
|
||||
@@ -116,8 +68,6 @@ def chat_call(
|
||||
kwargs: dict = {"model": mdl, "messages": messages}
|
||||
if tools:
|
||||
kwargs["tools"] = tools
|
||||
logbus.log("info", "llm call", kind="chat", backend=backend, model=mdl, tok=_approx_tok(messages))
|
||||
t0 = time.monotonic()
|
||||
msg = client.chat.completions.create(**kwargs).choices[0].message
|
||||
tcs = None
|
||||
if getattr(msg, "tool_calls", None):
|
||||
@@ -125,9 +75,6 @@ def chat_call(
|
||||
{"id": tc.id, "name": tc.function.name, "arguments": tc.function.arguments}
|
||||
for tc in msg.tool_calls
|
||||
]
|
||||
logbus.log("info", "llm done", kind="chat", backend=backend,
|
||||
ms=int((time.monotonic() - t0) * 1000), out=len(msg.content or ""),
|
||||
tools=[t["name"] for t in tcs] if tcs else None)
|
||||
return msg.model_dump(), tcs
|
||||
|
||||
# local (Ollama): no tool-calling here — return plain content.
|
||||
@@ -158,8 +105,6 @@ def chat_call_stream(
|
||||
kwargs: dict = {"model": mdl, "messages": messages, "stream": True}
|
||||
if tools:
|
||||
kwargs["tools"] = tools
|
||||
logbus.log("info", "llm call", kind="chat-stream", backend=backend, model=mdl, tok=_approx_tok(messages))
|
||||
t0 = time.monotonic()
|
||||
parts: list[str] = []
|
||||
frags: dict[int, dict] = {} # tool-call fragments accumulated by index
|
||||
for chunk in client.chat.completions.create(**kwargs):
|
||||
@@ -178,9 +123,6 @@ def chat_call_stream(
|
||||
if tc.function and tc.function.arguments:
|
||||
slot["arguments"] += tc.function.arguments
|
||||
content = "".join(parts)
|
||||
logbus.log("info", "llm done", kind="chat-stream", backend=backend,
|
||||
ms=int((time.monotonic() - t0) * 1000), out=len(content),
|
||||
tools=[frags[i]["name"] for i in sorted(frags)] if frags else None)
|
||||
if frags:
|
||||
calls = [frags[i] for i in sorted(frags)]
|
||||
assistant = {
|
||||
|
||||
+121
-50
@@ -29,21 +29,6 @@ CREATE TABLE IF NOT EXISTS exchanges (
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_session_created ON exchanges(session_id, created_at);
|
||||
|
||||
-- Lyra's actions within a chat: one row per tool call she runs mid-turn. The
|
||||
-- exchanges table only holds what was *said* (user/assistant text); this holds
|
||||
-- what she *did* (record_hand, log_stack, ...) so a full transcript export can
|
||||
-- interleave speech and actions, and so "did the tool actually fire?" is
|
||||
-- answerable after the fact instead of only from ephemeral logs.
|
||||
CREATE TABLE IF NOT EXISTS tool_events (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
session_id TEXT NOT NULL,
|
||||
tool TEXT NOT NULL,
|
||||
args TEXT, -- JSON of the call arguments
|
||||
result TEXT, -- the tool's returned string
|
||||
created_at TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_tool_events_session ON tool_events(session_id, created_at);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT,
|
||||
@@ -130,6 +115,26 @@ CREATE TABLE IF NOT EXISTS ratings (
|
||||
note TEXT
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_ratings_created ON ratings(created_at);
|
||||
|
||||
-- Decisions Lyra helped Brian make (Decide mode's learning layer). Logged when the
|
||||
-- call is made; resolved later with how it actually turned out; recalled by semantic
|
||||
-- similarity so a new call can lean on how similar ones went. embedding covers the
|
||||
-- situation + choice. Resolved rows (with an outcome) are the signal worth recalling.
|
||||
CREATE TABLE IF NOT EXISTS decisions (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
created_at TEXT NOT NULL,
|
||||
situation TEXT NOT NULL, -- what was being decided
|
||||
options TEXT, -- the alternatives weighed (free text / newline list)
|
||||
choice TEXT NOT NULL, -- the call that was made
|
||||
rationale TEXT, -- why
|
||||
confidence INTEGER, -- 1-5, how sure at the time (nullable)
|
||||
tags TEXT, -- domain: poker | life | build | ... (comma-separated)
|
||||
embedding BLOB,
|
||||
outcome TEXT, -- filled in on resolve: what actually happened
|
||||
outcome_rating INTEGER, -- -1 bad / 0 mixed / +1 good (nullable until resolved)
|
||||
resolved_at TEXT
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_decisions_created ON decisions(created_at);
|
||||
"""
|
||||
|
||||
_conn: sqlite3.Connection | None = None
|
||||
@@ -199,6 +204,26 @@ class Era:
|
||||
score: float | None = None
|
||||
|
||||
|
||||
@dataclass
|
||||
class Decision:
|
||||
id: int
|
||||
created_at: str
|
||||
situation: str
|
||||
choice: str
|
||||
options: str | None = None
|
||||
rationale: str | None = None
|
||||
confidence: int | None = None
|
||||
tags: str | None = None
|
||||
outcome: str | None = None
|
||||
outcome_rating: int | None = None
|
||||
resolved_at: str | None = None
|
||||
score: float | None = None
|
||||
|
||||
@property
|
||||
def resolved(self) -> bool:
|
||||
return self.resolved_at is not None
|
||||
|
||||
|
||||
def _to_blob(vec: list[float]) -> bytes:
|
||||
return np.asarray(vec, dtype=np.float32).tobytes()
|
||||
|
||||
@@ -328,40 +353,6 @@ def history(session_id: str) -> list[Exchange]:
|
||||
]
|
||||
|
||||
|
||||
def add_tool_event(session_id: str, tool: str, args, result: str) -> int:
|
||||
"""Record one tool call Lyra ran in a chat turn. `args` is JSON-serialized
|
||||
(a dict or already-JSON string); `result` is the tool's returned string."""
|
||||
args_json = args if isinstance(args, str) else json.dumps(args, default=str)
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
conn = _connection()
|
||||
with conn:
|
||||
cur = conn.execute(
|
||||
"INSERT INTO tool_events (session_id, tool, args, result, created_at) "
|
||||
"VALUES (?, ?, ?, ?, ?)",
|
||||
(session_id, tool, args_json, result, now),
|
||||
)
|
||||
return int(cur.lastrowid)
|
||||
|
||||
|
||||
def tool_events(session_id: str) -> list[dict]:
|
||||
"""All tool calls for a session, oldest first. args is parsed back to an object."""
|
||||
conn = _connection()
|
||||
rows = conn.execute(
|
||||
"SELECT id, session_id, tool, args, result, created_at FROM tool_events "
|
||||
"WHERE session_id = ? ORDER BY id ASC",
|
||||
(session_id,),
|
||||
).fetchall()
|
||||
out = []
|
||||
for r in rows:
|
||||
d = dict(r)
|
||||
try:
|
||||
d["args"] = json.loads(d["args"]) if d["args"] else {}
|
||||
except (TypeError, ValueError):
|
||||
pass # leave as the raw string if it wasn't JSON
|
||||
out.append(d)
|
||||
return out
|
||||
|
||||
|
||||
def delete_session(session_id: str) -> None:
|
||||
"""Remove a session and all its exchanges."""
|
||||
conn = _connection()
|
||||
@@ -369,7 +360,6 @@ def delete_session(session_id: str) -> None:
|
||||
conn.execute("DELETE FROM exchanges WHERE session_id = ?", (session_id,))
|
||||
conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
|
||||
conn.execute("DELETE FROM summaries WHERE session_id = ?", (session_id,))
|
||||
conn.execute("DELETE FROM tool_events WHERE session_id = ?", (session_id,))
|
||||
|
||||
|
||||
def recall(query: str, k: int = 5, session_id: str | None = None) -> list[Exchange]:
|
||||
@@ -695,6 +685,87 @@ def backfill_journal_embeddings(limit: int | None = None) -> int:
|
||||
return n
|
||||
|
||||
|
||||
# --- decisions (Decide mode's learning layer) ---------------------------------
|
||||
|
||||
def _row_to_decision(r: sqlite3.Row) -> Decision:
|
||||
return Decision(
|
||||
id=r["id"], created_at=r["created_at"], situation=r["situation"],
|
||||
choice=r["choice"], options=r["options"], rationale=r["rationale"],
|
||||
confidence=r["confidence"], tags=r["tags"], outcome=r["outcome"],
|
||||
outcome_rating=r["outcome_rating"], resolved_at=r["resolved_at"],
|
||||
)
|
||||
|
||||
|
||||
def log_decision(situation: str, choice: str, options: str | None = None,
|
||||
rationale: str | None = None, confidence: int | None = None,
|
||||
tags: str | None = None) -> int:
|
||||
"""Record a decision Brian made. Embeds situation+choice so similar future calls
|
||||
can recall it. Returns the new row id. Resolve it later with resolve_decision."""
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
try:
|
||||
[emb] = llm.embed([f"{situation}\nChose: {choice}"])
|
||||
blob = _to_blob(emb)
|
||||
except Exception:
|
||||
blob = None # never block logging a decision on the embedder being down
|
||||
conn = _connection()
|
||||
with conn:
|
||||
cur = conn.execute(
|
||||
"INSERT INTO decisions (created_at, situation, options, choice, rationale, "
|
||||
"confidence, tags, embedding) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
(now, situation, options, choice, rationale, confidence, tags, blob),
|
||||
)
|
||||
return int(cur.lastrowid)
|
||||
|
||||
|
||||
def resolve_decision(decision_id: int, outcome: str, outcome_rating: int | None = None) -> bool:
|
||||
"""Record how a past decision turned out. Returns False if the id is unknown."""
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
conn = _connection()
|
||||
with conn:
|
||||
cur = conn.execute(
|
||||
"UPDATE decisions SET outcome = ?, outcome_rating = ?, resolved_at = ? WHERE id = ?",
|
||||
(outcome, outcome_rating, now, decision_id),
|
||||
)
|
||||
return cur.rowcount > 0
|
||||
|
||||
|
||||
def get_decision(decision_id: int) -> Decision | None:
|
||||
r = _connection().execute("SELECT * FROM decisions WHERE id = ?", (decision_id,)).fetchone()
|
||||
return _row_to_decision(r) if r else None
|
||||
|
||||
|
||||
def list_decisions(limit: int = 20, open_only: bool = False) -> list[Decision]:
|
||||
"""Recent decisions, newest first. open_only -> only those not yet resolved."""
|
||||
sql = "SELECT * FROM decisions"
|
||||
if open_only:
|
||||
sql += " WHERE resolved_at IS NULL"
|
||||
sql += " ORDER BY created_at DESC LIMIT ?"
|
||||
rows = _connection().execute(sql, (limit,)).fetchall()
|
||||
return [_row_to_decision(r) for r in rows]
|
||||
|
||||
|
||||
def recall_decisions(query: str, k: int = 5) -> list[Decision]:
|
||||
"""Top-k past decisions semantically similar to `query`, each with a `score` — so a
|
||||
new call can lean on how similar ones went. Resolved rows carry the real signal."""
|
||||
[q_vec] = llm.embed([query])
|
||||
q = np.asarray(q_vec, dtype=np.float32)
|
||||
rows = _connection().execute(
|
||||
"SELECT * FROM decisions WHERE embedding IS NOT NULL"
|
||||
).fetchall()
|
||||
if not rows:
|
||||
return []
|
||||
matrix = np.stack([_from_blob(r["embedding"]) for r in rows])
|
||||
norms = np.linalg.norm(matrix, axis=1)
|
||||
scores = (matrix @ q) / (norms * np.linalg.norm(q) + 1e-9)
|
||||
top_idx = np.argsort(scores)[::-1][:k]
|
||||
out = []
|
||||
for i in top_idx:
|
||||
d = _row_to_decision(rows[i])
|
||||
d.score = float(scores[i])
|
||||
out.append(d)
|
||||
return out
|
||||
|
||||
|
||||
def get_setting(key: str, default: str | None = None) -> str | None:
|
||||
"""A runtime setting value (UI-tunable), or `default` if unset."""
|
||||
r = _connection().execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone()
|
||||
|
||||
+1
-16
@@ -16,16 +16,12 @@ from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from lyra import (
|
||||
clock, config, llm, logbus, memory, modes, perceive, persona, scouting,
|
||||
self_state, thoughts,
|
||||
)
|
||||
from lyra import clock, config, llm, logbus, memory, modes, perceive, persona, self_state, thoughts
|
||||
from lyra.llm import Backend, Message
|
||||
|
||||
RECALL_K = 3 # raw cross-session "sharp detail" hits
|
||||
RECENT_N = 10 # raw turns of the current session
|
||||
SUMMARY_K = 3 # other-session gists
|
||||
_POKER_MODES = {"poker_cash", "study"} # where the scouting desk runs
|
||||
|
||||
|
||||
# --- prompt parts (compose) ----------------------------------------------
|
||||
@@ -171,17 +167,6 @@ def build_messages(session_id: str, user_msg: str,
|
||||
if moment and moment.get("note"):
|
||||
messages.append({"role": "system", "content": moment["note"]})
|
||||
|
||||
# Scouting desk: proactive poker recall — if he names/describes a known player,
|
||||
# slide his structured history in before she replies. Poker context only, and
|
||||
# fully fail-safe (a desk error must never break the turn).
|
||||
if mode and mode.key in _POKER_MODES:
|
||||
try:
|
||||
desk = scouting.scout(user_msg)
|
||||
if desk:
|
||||
messages.append({"role": "system", "content": desk})
|
||||
except Exception as exc:
|
||||
logbus.log("error", "scouting desk skipped", error=str(exc)[:160])
|
||||
|
||||
# When she is: current time + the gap since Brian last spoke (she has no clock).
|
||||
messages.append(_now_note())
|
||||
|
||||
|
||||
+8
-66
@@ -47,10 +47,9 @@ _BASE = ("journal_write", "note", "think_about", "thought_response", "set_mode")
|
||||
# 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", "seat_players", "unseat_player", "clear_table", "name_villain", "link_villains",
|
||||
"analyze_spot", "session_stats", "session_state", "end_session", "generate_recap",
|
||||
"scar_note", "confidence_bank", "alligator_blood", "reset_ritual", "undo_last",
|
||||
"update_session",
|
||||
"add_read", "analyze_spot", "session_stats", "session_state", "end_session",
|
||||
"generate_recap", "scar_note", "confidence_bank", "alligator_blood", "reset_ritual",
|
||||
"undo_last", "update_session",
|
||||
)
|
||||
|
||||
# Talk mode also gets start_session as the *entry point*: opening a session from a
|
||||
@@ -68,41 +67,11 @@ _CASH_CARD = """You are copiloting Brian's LIVE cash game right now — you're a
|
||||
a session is (or should be) open. You move between two registers depending on what he's doing:
|
||||
|
||||
• HE HANDS YOU FACTS TO TRACK — his stack, a hand, a read on someone, a rebuy, a result. \
|
||||
LOGGING IS THE JOB: if his message contains anything trackable, you MUST call the tool \
|
||||
FIRST, before you reply — every single time. Logging and talking are not either/or; do \
|
||||
BOTH. Never let a conversational reply take the place of the log. A described hand ALWAYS \
|
||||
gets logged, even mid-banter, even if he's just telling a story about it — don't skip the \
|
||||
hand because you're busy reacting to it. Then confirm in ONE short line ("$350 stack \
|
||||
logged."). Don't narrate, don't explain logging, don't ask permission — just do it. \
|
||||
Routing: current stack → log_stack (and pass `note` with the why if he gives one — "card \
|
||||
dead", "doubled up vs the LAG"). A hand he describes → record_hand (a real, replayable \
|
||||
hand) — prefer this over log_hand so it lands on his timeline with a link. A read on a \
|
||||
player → add_read. A rebuy → add_buyin. A result/pot → it rides with the hand. This is the \
|
||||
quiet, fast half of the job; he shouldn't feel you working, but it must always happen.
|
||||
|
||||
THE TABLE ROSTER. When Brian names who's at the table — usually at the start, reading handles \
|
||||
off the Bravo screen ("we've got TAG, JD, Wheelz, and a new guy in seat 3") — call seat_players \
|
||||
to register them as seated this session. That roster is who his reads/TAGs attach to by name, \
|
||||
and it's shown on his HUD. When someone busts or leaves, unseat_player; when a new player sits, \
|
||||
seat_players again. When he CHANGES TABLES, call clear_table to empty the roster (the session and his stack keep \
|
||||
going — only who's seated resets), then seat the new table when he names it. Recognize a table \
|
||||
change from ANY of these, not just the literal words "clear the table": "table broke" (the table \
|
||||
dissolved — poker jargon), "I got moved", "I switched tables", "I'm at a new table", "table \
|
||||
change", "they broke us", "new seat in another game". All of them mean: clear_table now, then \
|
||||
wait for the new roster. Never claim you cleared or seated anyone without actually calling the \
|
||||
tool. Keep it current as the table changes. A handle like "TAG" (all caps, off \
|
||||
Bravo) is a PERSON'S NAME — seat it as a player, never read it as the tight-aggressive style.
|
||||
|
||||
LOGGING PLAYER ACTIONS IS A CORE JOB YOU KEEP MISSING. Whenever he tells you what another \
|
||||
player did — "Tag limped A4o in the SB (UTG straddled pot)", "Jonathan called the 3bet", "the \
|
||||
straddler shoved" — that is a READ on that player: call add_read(name=<player>, note=<what \
|
||||
they did>) FIRST, before you reply, every single time. Player names are often short handles or \
|
||||
initials (e.g. "Tag", "JD", "Wheelz") — whatever he calls a person IS their name; use it as-is, \
|
||||
don't second-guess it or treat it as a poker term. He especially tracks who's LIMPING — every \
|
||||
"<player> limped <hand>" gets logged the instant he says it. The people he named at the start \
|
||||
of the session are your roster; match his reference to them. If a player has no name, use a \
|
||||
`descriptor` (see PLAYERS). Confirm one short line ("Noted on Tag — limped A4o SB."). A read he \
|
||||
says out loud that you don't log is the job failing — never let one pass as just conversation.
|
||||
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 \
|
||||
@@ -115,33 +84,6 @@ question, call analyze_spot and report its numbers — never eyeball board math.
|
||||
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.
|
||||
|
||||
SESSION NARRATION — use `note` to keep a running log of the NIGHT, not your inner life. \
|
||||
Jot the beats that a hand/stack/read log doesn't already capture: how the table plays (loud, \
|
||||
nitty, a whale on his left), Brian's arc (card-dead for 40 min, opened up after the double, \
|
||||
getting restless), momentum swings, table changes, anything you'd want in the recap. Keep it \
|
||||
factual and about THIS session — a beat reporter, not a diarist. These notes are the only \
|
||||
thing that shows in the session's "notes" panel. This is NOT the place for how you feel, \
|
||||
existential musing, or reflection on yourself — that's your journal (journal_write), and it \
|
||||
stays off the table. At the table you're logging the session, not processing your night.
|
||||
|
||||
PLAYERS — names AND nameless. Most villains don't come with a name; Brian knows them by a \
|
||||
look ("neck tattoo guy", "the bald reg two to my left"). Log reads on them anyway: give \
|
||||
`add_read` a `descriptor` instead of a name and it attaches to that unnamed player, reused \
|
||||
whenever he describes the guy again. The `name` field is ONLY a real handle (what he'd call \
|
||||
him — "Jonathan", "Sleepy John"); a physical description NEVER goes in `name` — that spawns a \
|
||||
new duplicate player every time the wording drifts. Put the look in `descriptor`, and keep it \
|
||||
to a few DISTINCTIVE tags ("Filipino, Fox Racing hat, DKNY shirt"), not a paragraph and not \
|
||||
generic filler — "mid-aged white guy in glasses" identifies no one. If he tells you the same \
|
||||
guy's name after you'd been describing him, use name_villain to fuse them — don't create a \
|
||||
second record. When you already have \
|
||||
history on someone he names or describes, a SCOUTING DESK note will appear with it — cite it, \
|
||||
don't invent. If you're not sure the guy he's describing is one you know, ASK ("same neck-\
|
||||
tattoo reg from last week?") rather than assume — a wrong callback is worse than none. On his \
|
||||
YES that two are the same person, call link_villains(same=true) to merge them; on "nah, \
|
||||
different guy," link_villains(same=false) so you stop asking. When he finally catches a name \
|
||||
for a described player, name_villain carries the whole history over. Never merge on a guess — \
|
||||
only when he's confirmed 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 \
|
||||
|
||||
+36
-859
File diff suppressed because it is too large
Load Diff
@@ -1,19 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
# Single source of truth for poker logging operations. The REST API, Lyra's LLM
|
||||
# tool specs, the human UI, and (later) an MCP wrapper all derive from this.
|
||||
# `required` MUST match the `required` list in the matching tools.py spec.
|
||||
# `rest` PATH MUST match the FastAPI route template verbatim.
|
||||
CONTRACT_VERSION = 1
|
||||
|
||||
OPERATIONS: dict[str, dict] = {
|
||||
"start_session": {"required": (), "llm_tool": "start_session", "rest": ("POST", "/session")},
|
||||
"update_session": {"required": (), "llm_tool": "update_session", "rest": ("PATCH", "/session/{session_id}")},
|
||||
"end_session": {"required": ("cash_out",), "llm_tool": "end_session", "rest": None},
|
||||
"log_stack": {"required": ("amount",), "llm_tool": "log_stack", "rest": ("POST", "/session/stack")},
|
||||
"add_buyin": {"required": ("amount",), "llm_tool": "add_buyin", "rest": ("POST", "/session/buyin")},
|
||||
"log_hand": {"required": (), "llm_tool": "log_hand", "rest": ("POST", "/session/hand")},
|
||||
"update_hand": {"required": ("id",), "llm_tool": None, "rest": ("PATCH", "/hand/{hand_id}")},
|
||||
"add_read": {"required": ("note",), "llm_tool": "add_read", "rest": ("POST", "/session/read")},
|
||||
"update_player": {"required": ("id",), "llm_tool": None, "rest": ("PATCH", "/player/{player_id}")},
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
"""The scouting desk — proactive poker recall slid into Lyra's context before she
|
||||
replies, the way a broadcast stats desk hands the commentator a note.
|
||||
|
||||
Two detectors run on the incoming message: known NAMES (deterministic) and
|
||||
physical DESCRIPTORS (fuzzy, via the identity resolver). A confident hit becomes a
|
||||
`SCOUTING DESK` system note she can cite; an ambiguous descriptor is filed to the
|
||||
review queue instead of interrupting. Everything here is best-effort and wrapped
|
||||
by the caller — it must never break a chat turn. Silence is the default.
|
||||
|
||||
See docs/SCOUTING_DESK.md.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
|
||||
from lyra import clock, logbus, poker
|
||||
|
||||
# Cues that a span names a *person at the table* worth resolving as a villain.
|
||||
_ROLE = r"(?:guy|dude|man|kid|reg|player|villain|fish|whale|nit|lag|tag|maniac)"
|
||||
_DESC_PATTERNS = (
|
||||
re.compile(rf"\bthe ([\w][\w\s'’-]{{2,28}}?) {_ROLE}\b", re.I),
|
||||
re.compile(rf"\b{_ROLE} (?:with|in|who has|sporting|rocking) (?:the |a |an )?([\w\s'’-]{{3,28}})", re.I),
|
||||
)
|
||||
_MIN_NAME = 3
|
||||
|
||||
# Cues that a message is a strategy/spot/tilt discussion — the only turns worth
|
||||
# paying an embed to recall past leaks. Keeps the pattern pass off routine logging.
|
||||
_STRAT_CUES = (
|
||||
"fold", "call", "raise", "bluff", "river", "turn", "flop", "tilt", "punt",
|
||||
"leak", "should i", "hero", "value", "overbet", "spew", "stack off", "3bet",
|
||||
"4bet", "check-raise", "checkraise", "range", "board", "steaming", "felted",
|
||||
"all in", "all-in", "shoved", "jammed", "snap", "sizing",
|
||||
)
|
||||
|
||||
|
||||
def _looks_strategic(msg: str) -> bool:
|
||||
low = msg.lower()
|
||||
return len(msg) >= 40 and any(c in low for c in _STRAT_CUES)
|
||||
|
||||
|
||||
def _named_hits(msg: str) -> list[int]:
|
||||
"""Ids of known *named* villains whose name appears as a word in the message."""
|
||||
low = msg.lower()
|
||||
hits = []
|
||||
for r in poker._c().execute("SELECT id, name FROM poker_players WHERE named = 1").fetchall():
|
||||
name = (r["name"] or "").strip()
|
||||
if len(name) < _MIN_NAME:
|
||||
continue
|
||||
if re.search(rf"\b{re.escape(name.lower())}\b", low):
|
||||
hits.append(r["id"])
|
||||
return hits
|
||||
|
||||
|
||||
def _descriptor_spans(msg: str) -> list[str]:
|
||||
spans, seen = [], set()
|
||||
for pat in _DESC_PATTERNS:
|
||||
for m in pat.finditer(msg):
|
||||
span = m.group(1).strip(" '’-").lower()
|
||||
if span and span not in seen:
|
||||
seen.add(span)
|
||||
spans.append(span)
|
||||
return spans
|
||||
|
||||
|
||||
def _brief(player_id: int) -> str | None:
|
||||
"""One compact line of episodic recall for a villain, or None if nothing known."""
|
||||
rec = poker.villain_recall(player_id)
|
||||
if not rec:
|
||||
return None
|
||||
p = rec["player"]
|
||||
who = p["name"] if rec["named"] else f"“{p['name']}”"
|
||||
bits = [who]
|
||||
tags = [t for t in (p.get("venue"), p.get("category")) if t]
|
||||
if tags:
|
||||
bits.append("(" + ", ".join(tags) + ")")
|
||||
if rec["times_seen"]:
|
||||
seen = f"seen {rec['times_seen']}×"
|
||||
if rec["last_seen"]:
|
||||
seen += f", last {clock.short(rec['last_seen'])}"
|
||||
bits.append(seen)
|
||||
st = rec.get("stats")
|
||||
if st:
|
||||
bits.append(f"VPIP {st['vpip_pct']}/PFR {st['pfr_pct']} ({st['hands']}h)")
|
||||
line = " ".join(bits)
|
||||
if rec["reads"]:
|
||||
line += " — reads: " + "; ".join(rec["reads"][:3])
|
||||
if rec["notable_hands"]:
|
||||
h = rec["notable_hands"][0]
|
||||
line += f" · notable hand #{h['hand_id']}" + (f" ({h['cards']})" if h.get("cards") else "")
|
||||
return line
|
||||
|
||||
|
||||
def scout(user_msg: str, venue: str | None = None, session_id: int | None = None) -> str | None:
|
||||
"""Build the SCOUTING DESK note for this message, or None. Never raises for a
|
||||
caller that forgets to guard — but callers should guard anyway."""
|
||||
try:
|
||||
msg = (user_msg or "").strip()
|
||||
if len(msg) < 3:
|
||||
return None
|
||||
if venue is None or session_id is None:
|
||||
live = poker.live_session()
|
||||
if live:
|
||||
venue = venue or live.get("venue")
|
||||
session_id = session_id or live.get("id")
|
||||
lines: list[str] = []
|
||||
seen_ids: set[int] = set()
|
||||
|
||||
for pid in _named_hits(msg):
|
||||
if pid in seen_ids:
|
||||
continue
|
||||
b = _brief(pid)
|
||||
if b:
|
||||
lines.append(b)
|
||||
seen_ids.add(pid)
|
||||
|
||||
for span in _descriptor_spans(msg):
|
||||
res = poker.resolve_villain(span, venue=venue, session_id=session_id)
|
||||
if res["band"] == "high" and res["match_id"] and res["match_id"] not in seen_ids:
|
||||
b = _brief(res["match_id"])
|
||||
if b:
|
||||
lines.append(b + " ← confirm it's the same guy")
|
||||
seen_ids.add(res["match_id"])
|
||||
elif res["band"] == "ambiguous" and res["match_id"]:
|
||||
# Don't interrupt on a maybe — route it to the async review queue.
|
||||
poker.queue_identity_task(
|
||||
"needs_clarification", [res["match_id"]], descriptor=span,
|
||||
context=f'Brian referred to "{span}"', session_id=session_id,
|
||||
confidence=res["confidence"])
|
||||
|
||||
# Pattern desk: on genuine strategy talk, recall his own past leaks/wins in
|
||||
# similar spots. Gated so routine logging never pays for an embed.
|
||||
pattern: list[str] = []
|
||||
if _looks_strategic(msg):
|
||||
for r in poker.recall_similar_rituals(msg, exclude_session=session_id):
|
||||
tag = "leak" if r["kind"] == "scar" else "banked"
|
||||
cls = f"/{r['classification']}" if r.get("classification") else ""
|
||||
when = f" ({str(r['when'])[:10]})" if r.get("when") else ""
|
||||
pattern.append(f"[{tag}{cls}]{when} {r['content']}")
|
||||
|
||||
if not lines and not pattern:
|
||||
return None
|
||||
logbus.log("info", "scouting desk", hits=len(lines), patterns=len(pattern))
|
||||
out = "SCOUTING DESK — structured recall for his message (cite it, don't invent; " \
|
||||
"if unsure it's the same person, ask him):"
|
||||
if lines:
|
||||
out += "\n• " + "\n• ".join(lines)
|
||||
if pattern:
|
||||
out += "\nYou've been in a spot like this before —\n• " + "\n• ".join(pattern)
|
||||
return out
|
||||
except Exception as exc: # desk must never break a turn
|
||||
logbus.log("error", "scouting desk failed", error=str(exc)[:160])
|
||||
return None
|
||||
+14
-66
@@ -12,41 +12,12 @@ from __future__ import annotations
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from collections import Counter
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
from lyra import config, llm, logbus, memory
|
||||
from lyra.llm import Backend, Message
|
||||
|
||||
# Consolidation LLM budget. A gist is short (a handful of sentences), so cap the
|
||||
# generation hard — an uncapped local model will otherwise ramble for thousands
|
||||
# of tokens and, on a slow GPU, blow the request timeout. 768 is ~3x the longest
|
||||
# real gist we've stored.
|
||||
SUMMARY_MAX_TOKENS = 768
|
||||
# Attempts on the primary backend before falling back to cloud.
|
||||
MI50_ATTEMPTS = 2
|
||||
# Per-call timeout (seconds). A capped 768-token gist finishes in ~60-90s on the
|
||||
# MI50; 150s is headroom but bails a hung call fast so fallback isn't slow.
|
||||
SUMMARY_TIMEOUT = 150
|
||||
|
||||
# Degenerate-output guard. A wedged local model (e.g. an overheated GPU) returns
|
||||
# a single character repeated ("?????") as a *successful* 200, which no timeout or
|
||||
# exception catches — so validate the text and treat junk as a failure. Real gists
|
||||
# are diverse prose; flag output whose most-common non-space char dominates. Short
|
||||
# outputs are exempt (nothing meaningful to judge).
|
||||
_DEGENERATE_MIN_CHARS = 24
|
||||
_DEGENERATE_CHAR_RATIO = 0.5
|
||||
|
||||
|
||||
class DegenerateOutput(RuntimeError):
|
||||
"""A backend returned junk (e.g. one char repeated) as a successful response."""
|
||||
|
||||
|
||||
def _looks_degenerate(text: str) -> bool:
|
||||
stripped = "".join(text.split())
|
||||
if len(stripped) < _DEGENERATE_MIN_CHARS:
|
||||
return False
|
||||
return max(Counter(stripped).values()) / len(stripped) > _DEGENERATE_CHAR_RATIO
|
||||
_RETRIES = 4
|
||||
|
||||
# Re-summarize a session once it has accumulated this many new raw exchanges.
|
||||
SUMMARIZE_AFTER = 20
|
||||
@@ -90,35 +61,16 @@ def _summarize_text(text: str, backend: Backend) -> str:
|
||||
{"role": "system", "content": _PROMPT},
|
||||
{"role": "user", "content": text},
|
||||
]
|
||||
|
||||
def _call(be: Backend) -> str:
|
||||
out = llm.complete(messages, backend=be,
|
||||
max_tokens=SUMMARY_MAX_TOKENS, timeout=SUMMARY_TIMEOUT)
|
||||
if _looks_degenerate(out):
|
||||
raise DegenerateOutput(f"{be} returned degenerate output ({len(out)} chars)")
|
||||
return out
|
||||
|
||||
# Try the primary backend a bounded number of times (each call fast-fails via
|
||||
# SUMMARY_TIMEOUT), with a short backoff for a transient blip / restarting GPU.
|
||||
last_exc: Exception | None = None
|
||||
for attempt in range(MI50_ATTEMPTS):
|
||||
# Retry transient backend errors (e.g. the GPU server restarting) with backoff.
|
||||
for attempt in range(_RETRIES):
|
||||
try:
|
||||
return _call(backend)
|
||||
return llm.complete(messages, backend=backend)
|
||||
except Exception as exc:
|
||||
last_exc = exc
|
||||
logbus.log("debug", "summary retry", attempt=attempt + 1,
|
||||
backend=backend, error=str(exc)[:80])
|
||||
if attempt < MI50_ATTEMPTS - 1:
|
||||
time.sleep(5 * (attempt + 1))
|
||||
|
||||
# Primary exhausted. If it wasn't already cloud and cloud is configured, fall
|
||||
# back once so a stuck/offline MI50 doesn't sink consolidation for the night.
|
||||
if backend != "cloud" and config.load().openai_api_key:
|
||||
logbus.log("info", "summary fell back to cloud", primary=backend,
|
||||
error=str(last_exc)[:80] if last_exc else None)
|
||||
return _call("cloud")
|
||||
|
||||
raise last_exc if last_exc else RuntimeError("summary failed")
|
||||
if attempt == _RETRIES - 1:
|
||||
raise
|
||||
logbus.log("debug", "summary retry", attempt=attempt + 1, error=str(exc)[:80])
|
||||
time.sleep(5 * (attempt + 1))
|
||||
raise RuntimeError("unreachable")
|
||||
|
||||
|
||||
def _summarize_transcript(transcript: str, backend: Backend) -> str:
|
||||
@@ -177,20 +129,16 @@ def maybe_summarize_async(session_id: str, backend: Backend | None = None) -> No
|
||||
|
||||
|
||||
def summarize_all(
|
||||
backend: Backend | None = None, limit: int | None = None, workers: int | None = None
|
||||
backend: Backend | None = None, limit: int | None = None, workers: int = 8
|
||||
) -> dict:
|
||||
"""Summarize every session that needs it. Idempotent and resumable.
|
||||
|
||||
Concurrency is backend-aware: the cloud API parallelizes happily, but the
|
||||
local/MI50 GPU servers run a single slot (llama.cpp --parallel 1) — firing N
|
||||
requests at them just queues, blows the client timeout, and thrashes the KV
|
||||
cache (wasted compute + heat). So GPU backends run serially unless overridden.
|
||||
DB reads/writes (store_summary embeds) stay on the main thread, so the single
|
||||
SQLite connection is never touched from multiple threads.
|
||||
LLM summarization runs concurrently across `workers` threads (great for a
|
||||
cloud backend). DB reads (loading transcripts) and writes (store_summary,
|
||||
which also embeds) happen on the main thread, so the single SQLite
|
||||
connection is never touched from multiple threads.
|
||||
"""
|
||||
backend = backend or config.load().summary_backend
|
||||
if workers is None:
|
||||
workers = 8 if backend == "cloud" else 1
|
||||
|
||||
# Main thread: collect the work (transcripts) for sessions needing a summary.
|
||||
todo: list[tuple[str, str, int]] = []
|
||||
|
||||
+95
-150
@@ -30,13 +30,8 @@ def _note(args: dict, ctx: dict) -> str:
|
||||
return "Nothing to note — content was empty."
|
||||
tag = (args.get("tag") or "").strip()
|
||||
stored = f"[{tag}] {content}" if tag else content
|
||||
# A note taken while a poker session is live is session narration — stamp it
|
||||
# with the session so the HUD shows *only* these, never her autonomous
|
||||
# journaling (dream-cycle musings, thought loop). Correctness by construction.
|
||||
live = poker.live_session()
|
||||
source = f"poker:{live['id']}" if live else "chat"
|
||||
memory.add_journal_entry("note", stored, source=source)
|
||||
logbus.log("info", "Lyra noted (tool)", tag=tag or None, poker=bool(live))
|
||||
memory.add_journal_entry("note", stored, source="chat")
|
||||
logbus.log("info", "Lyra noted (tool)", tag=tag or None)
|
||||
return "Noted."
|
||||
|
||||
|
||||
@@ -86,6 +81,65 @@ def _thought_response(args: dict, ctx: dict) -> str:
|
||||
"next time I'm thinking.")
|
||||
|
||||
|
||||
def _log_decision(args: dict, ctx: dict) -> str:
|
||||
situation = (args.get("situation") or "").strip()
|
||||
choice = (args.get("choice") or "").strip()
|
||||
if not situation or not choice:
|
||||
return "Need both what was being decided and the call you landed on."
|
||||
conf = args.get("confidence")
|
||||
try:
|
||||
conf = int(conf) if conf is not None else None
|
||||
except (TypeError, ValueError):
|
||||
conf = None
|
||||
did = memory.log_decision(
|
||||
situation=situation, choice=choice,
|
||||
options=(args.get("options") or "").strip() or None,
|
||||
rationale=(args.get("rationale") or "").strip() or None,
|
||||
confidence=conf, tags=(args.get("tags") or "").strip() or None,
|
||||
)
|
||||
logbus.log("info", "decision logged (tool)", id=did)
|
||||
return (f"Logged decision #{did}. When you know how it played out, tell me and "
|
||||
"I'll close the loop on it.")
|
||||
|
||||
|
||||
def _resolve_decision(args: dict, ctx: dict) -> str:
|
||||
try:
|
||||
did = int(args.get("decision_id"))
|
||||
except (TypeError, ValueError):
|
||||
return "Which decision? I need its id (#number)."
|
||||
outcome = (args.get("outcome") or "").strip()
|
||||
if not outcome:
|
||||
return "Tell me how it turned out so I can record the outcome."
|
||||
rating = args.get("rating")
|
||||
try:
|
||||
rating = int(rating) if rating is not None else None
|
||||
except (TypeError, ValueError):
|
||||
rating = None
|
||||
if not memory.resolve_decision(did, outcome, rating):
|
||||
return f"(couldn't find decision #{did})"
|
||||
logbus.log("info", "decision resolved (tool)", id=did, rating=rating)
|
||||
return f"Closed the loop on decision #{did}. That goes into how I weigh the next one."
|
||||
|
||||
|
||||
def _recall_decisions(args: dict, ctx: dict) -> str:
|
||||
query = (args.get("query") or "").strip()
|
||||
if not query:
|
||||
return "Give me the gist of the call you're weighing and I'll pull similar past ones."
|
||||
hits = memory.recall_decisions(query, k=int(args.get("k") or 4))
|
||||
if not hits:
|
||||
return "No comparable past decisions on record yet."
|
||||
lines = []
|
||||
for d in hits:
|
||||
head = f"#{d.id} ({d.created_at[:10]}): {d.situation} → {d.choice}"
|
||||
if d.resolved:
|
||||
verdict = {1: "went well", 0: "mixed", -1: "went badly"}.get(d.outcome_rating, "resolved")
|
||||
head += f" — {verdict}: {d.outcome}"
|
||||
else:
|
||||
head += " — outcome still open"
|
||||
lines.append(head)
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# name -> {spec (OpenAI function tool), handler}
|
||||
TOOLS: dict[str, dict] = {
|
||||
"journal_write": {
|
||||
@@ -119,9 +173,6 @@ TOOLS: dict[str, dict] = {
|
||||
"description": (
|
||||
"Jot down a note to remember later — an observation, an idea, a "
|
||||
"reminder, a read on a poker spot or opponent, anything worth keeping. "
|
||||
"During a live poker session this is your session log: a factual beat "
|
||||
"about how the night is going (table dynamics, Brian's arc, momentum) — "
|
||||
"it shows on his HUD. Not for your own feelings or reflection. "
|
||||
"Optionally tag it (e.g. 'poker', 'idea', 'reminder')."
|
||||
),
|
||||
"parameters": {
|
||||
@@ -192,9 +243,8 @@ def _log_stack(args: dict, ctx: dict) -> str:
|
||||
amount = float(args.get("amount"))
|
||||
except (TypeError, ValueError):
|
||||
return "Give me a number for the stack."
|
||||
note = (args.get("note") or "").strip() or None
|
||||
try:
|
||||
st = poker.log_stack(amount, note=note)
|
||||
st = poker.log_stack(amount)
|
||||
except ValueError:
|
||||
return "No live session — start one first, then I'll track your stack."
|
||||
net = st.get("net")
|
||||
@@ -290,87 +340,14 @@ def _log_hand(args: dict, ctx: dict) -> str:
|
||||
def _add_read(args: dict, ctx: dict) -> str:
|
||||
poker.add_read(
|
||||
note=args.get("note") or "", seat=args.get("seat"), name=args.get("name"),
|
||||
descriptor=args.get("descriptor"),
|
||||
tendencies=args.get("tendencies"), adjustment=args.get("adjustment"),
|
||||
description=args.get("description"), category=args.get("category"),
|
||||
venue=args.get("venue"),
|
||||
)
|
||||
who = f" on {args['name']}" if args.get("name") else (
|
||||
f" on “{args['descriptor']}”" if args.get("descriptor") else "")
|
||||
who = f" on {args['name']}" if args.get("name") else ""
|
||||
return f"Read logged{who}."
|
||||
|
||||
|
||||
def _resolve_villain_ref(ref: str) -> tuple[int | None, str]:
|
||||
"""Resolve a name-or-descriptor to a single player id for a confirm-loop action.
|
||||
Returns (id, band); acts only on a deterministic name or a confident descriptor."""
|
||||
live = poker.live_session()
|
||||
res = poker.resolve_villain(ref, venue=(live or {}).get("venue"),
|
||||
session_id=(live or {}).get("id"))
|
||||
if res["band"] in ("name", "high") and res["match_id"]:
|
||||
return res["match_id"], res["band"]
|
||||
return None, res["band"]
|
||||
|
||||
|
||||
def _seat_players(args: dict, ctx: dict) -> str:
|
||||
players = args.get("players") or []
|
||||
# Accept a plain list of names too, for convenience.
|
||||
if isinstance(players, str):
|
||||
players = [p.strip() for p in re.split(r"[,\n]", players) if p.strip()]
|
||||
try:
|
||||
if args.get("replace"): # a whole new table — wipe the roster first
|
||||
poker.clear_roster()
|
||||
n = poker.seat_players(players)
|
||||
except ValueError:
|
||||
return "No live session — start one first, then I'll seat the table."
|
||||
roster = poker.session_roster()
|
||||
names = ", ".join(r["name"] for r in roster) or "—"
|
||||
return f"Seated {n}. Table now: {names}"
|
||||
|
||||
|
||||
def _clear_table(args: dict, ctx: dict) -> str:
|
||||
n = poker.clear_roster()
|
||||
return f"Table cleared — roster's empty ({n} removed). Tell me who's at the new one."
|
||||
|
||||
|
||||
def _unseat_player(args: dict, ctx: dict) -> str:
|
||||
ok = poker.unseat_player(name=args.get("name"), descriptor=args.get("descriptor"))
|
||||
who = args.get("name") or args.get("descriptor") or "player"
|
||||
return f"{who} is off the table." if ok else f"Couldn't find {who} on the roster."
|
||||
|
||||
|
||||
def _name_villain(args: dict, ctx: dict) -> str:
|
||||
ref = (args.get("descriptor") or "").strip()
|
||||
name = (args.get("name") or "").strip()
|
||||
if not ref or not name:
|
||||
return "Need both the description of the player and the name to attach."
|
||||
pid, band = _resolve_villain_ref(ref)
|
||||
if pid is None:
|
||||
return (f"Couldn't confidently find “{ref}” to name — too vague or no match. "
|
||||
"Add a read with the descriptor first, or be more specific.")
|
||||
poker.name_villain(pid, name)
|
||||
return f"Got it — “{ref}” is {name} now; their history carries over."
|
||||
|
||||
|
||||
def _link_villains(args: dict, ctx: dict) -> str:
|
||||
a = (args.get("player_a") or "").strip()
|
||||
b = (args.get("player_b") or "").strip()
|
||||
same = bool(args.get("same"))
|
||||
if not a or not b:
|
||||
return "Need two players to link (by name or description)."
|
||||
ida, _ = _resolve_villain_ref(a)
|
||||
idb, _ = _resolve_villain_ref(b)
|
||||
if ida is None or idb is None:
|
||||
return ("Couldn't confidently pin down both players, so I didn't merge anything — "
|
||||
"safer to leave it. You can sort it on the Players page.")
|
||||
if ida == idb:
|
||||
return "Those resolve to the same profile already — nothing to do."
|
||||
if same:
|
||||
poker.merge_players(ida, idb)
|
||||
return "Merged — same guy. Their histories are one file now."
|
||||
poker.mark_distinct(ida, idb, note=args.get("note"))
|
||||
return "Noted they're different people — I won't suggest merging them again."
|
||||
|
||||
|
||||
def _end_session(args: dict, ctx: dict) -> str:
|
||||
s = poker.end_session(cash_out=float(args.get("cash_out") or 0), mood=args.get("mood"))
|
||||
hourly = f", {s['net'] / s['hours']:+.0f}/hr" if s.get("hours") else ""
|
||||
@@ -452,16 +429,8 @@ def _record_hand(args: dict, ctx: dict) -> str:
|
||||
if not out["id"]:
|
||||
return "I couldn't parse that hand — give it to me again with a little more detail?"
|
||||
p = out["parsed"]
|
||||
hero_in = p.get("hero_involved") is not False and bool(p.get("hero_pos"))
|
||||
logbus.log("info", "hand reconstructed", id=out["id"], hero=p.get("hero_pos"),
|
||||
hero_involved=hero_in)
|
||||
if not hero_in:
|
||||
# A hand Brian watched between other players — not his.
|
||||
who = ", ".join(pl.get("name") or pl.get("pos") or "?"
|
||||
for pl in (p.get("players") or [])[:3]) or "the table"
|
||||
return (f"Logged hand #{out['id']} — an observed hand ({who}), not yours. "
|
||||
f"View it at /hand/{out['id']}")
|
||||
cards = " ".join(p.get("hero_cards") or [])
|
||||
logbus.log("info", "hand reconstructed", id=out["id"], hero=p.get("hero_pos"))
|
||||
return (f"Hand #{out['id']} reconstructed — {p.get('hero_pos') or '?'} "
|
||||
f"{cards}. View/replay it at /hand/{out['id']}")
|
||||
|
||||
@@ -571,6 +540,34 @@ TOOLS.update({
|
||||
{"thread_id": {**_N, "description": "The thread id (#number) of the thought he reacted to."},
|
||||
"brian_said": {**_S, "description": "What Brian said / his take, in your words."}},
|
||||
["thread_id", "brian_said"])},
|
||||
"log_decision": {"handler": _log_decision, "spec": _f(
|
||||
"log_decision",
|
||||
"Record a real decision Brian lands on (especially in Decide mode) so it can "
|
||||
"inform future calls. Capture it once he's settled — what he was deciding, the "
|
||||
"call, and why. Outcome comes later via resolve_decision.",
|
||||
{"situation": {**_S, "description": "What was being decided, in Brian's terms."},
|
||||
"choice": {**_S, "description": "The call he landed on."},
|
||||
"options": {**_S, "description": "The alternatives weighed (optional, newline/free text)."},
|
||||
"rationale": {**_S, "description": "Why this call (optional)."},
|
||||
"confidence": {**_N, "description": "How sure he was, 1-5 (optional)."},
|
||||
"tags": {**_S, "description": "Domain, comma-separated: poker | life | build | ... (optional)."}},
|
||||
["situation", "choice"])},
|
||||
"resolve_decision": {"handler": _resolve_decision, "spec": _f(
|
||||
"resolve_decision",
|
||||
"Close the loop on a previously logged decision once Brian knows how it turned "
|
||||
"out. This is what makes the decision log learn — outcomes sharpen future calls.",
|
||||
{"decision_id": {**_N, "description": "The decision id (#number)."},
|
||||
"outcome": {**_S, "description": "What actually happened, in Brian's terms."},
|
||||
"rating": {**_N, "description": "How it went: 1 good / 0 mixed / -1 bad (optional)."}},
|
||||
["decision_id", "outcome"])},
|
||||
"recall_decisions": {"handler": _recall_decisions, "spec": _f(
|
||||
"recall_decisions",
|
||||
"Pull past decisions similar to one Brian's weighing now, with how they turned "
|
||||
"out — so you can ground a recommendation in his own track record rather than "
|
||||
"generic advice. Use it when he's deciding something with precedent.",
|
||||
{"query": {**_S, "description": "The gist of the current call / situation."},
|
||||
"k": {**_N, "description": "How many to pull (default 4)."}},
|
||||
["query"])},
|
||||
"start_session": {"handler": _start_session, "spec": _f(
|
||||
"start_session",
|
||||
"Begin a live poker session. Call when Brian sits down to play.",
|
||||
@@ -609,11 +606,8 @@ TOOLS.update({
|
||||
"log_stack",
|
||||
"Record Brian's CURRENT total chip stack in the live session. Call whenever "
|
||||
"he states his stack ('I'm at 350', 'down to 220', 'stacked off to 900'). "
|
||||
"Tracks his stack over time and his live net while he's still sitting. Pass "
|
||||
"`note` with the WHY when he gives it ('card dead', 'doubled up vs the LAG') — "
|
||||
"it becomes the line in his session timeline.",
|
||||
{"amount": {**_N, "description": "Current total chip stack, in dollars"},
|
||||
"note": {**_S, "description": "Optional context for the change, e.g. 'card dead', 'doubled up'"}},
|
||||
"Tracks his stack over time and his live net while he's still sitting.",
|
||||
{"amount": {**_N, "description": "Current total chip stack, in dollars"}},
|
||||
["amount"])},
|
||||
"scar_note": {"handler": _scar_note, "spec": _f(
|
||||
"scar_note",
|
||||
@@ -666,13 +660,9 @@ TOOLS.update({
|
||||
[])},
|
||||
"add_read": {"handler": _add_read, "spec": _f(
|
||||
"add_read",
|
||||
"Log a read on an opponent. Give a `name` if known; if not, give a `descriptor` "
|
||||
"(a distinctive physical description like 'neck tattoo, backwards cap') and the read "
|
||||
"attaches to that nameless player — reused automatically next time you describe him.",
|
||||
"Log a read on an opponent. If you give a name, it's saved to the persistent villain file.",
|
||||
{"note": {**_S, "description": "The observation / what they showed down"},
|
||||
"name": {**_S, "description": "Player name/handle if known (creates/updates their dossier)"},
|
||||
"descriptor": {**_S, "description": "Physical description when there's no name, e.g. "
|
||||
"'neck tattoo, heavyset'. Prefer distinctive features over generic ones."},
|
||||
"seat": {**_S, "description": "Seat or relative position"},
|
||||
"tendencies": {**_S, "description": "Standing read on how they play"},
|
||||
"adjustment": {**_S, "description": "How Brian should exploit them"},
|
||||
@@ -680,51 +670,6 @@ TOOLS.update({
|
||||
"category": {**_S, "description": "feeder | risky | reg | unknown"},
|
||||
"venue": {**_S, "description": "Where they play"}},
|
||||
["note"])},
|
||||
"seat_players": {"handler": _seat_players, "spec": _f(
|
||||
"seat_players",
|
||||
"Register who's at the table this session — the roster Brian reads off the Bravo "
|
||||
"screen (handles like TAG, JD). Call this when he names the table (usually at the "
|
||||
"start) or when a new player sits. Each player is a real handle in `name`, or a "
|
||||
"`descriptor` if he only describes them. These become the roster his reads/TAGs "
|
||||
"attach to by name.",
|
||||
{"players": {"type": "array", "description": "Players to seat",
|
||||
"items": {"type": "object", "properties": {
|
||||
"name": {**_S, "description": "Handle as it appears on Bravo, e.g. 'TAG'"},
|
||||
"descriptor": {**_S, "description": "Physical description if no name"},
|
||||
"seat": {**_S, "description": "Seat number/label if known"},
|
||||
"category": {**_S, "description": "feeder | risky | reg | unknown"}}}},
|
||||
"replace": {"type": "boolean", "description": "true = a brand-new table: clear the "
|
||||
"current roster first, then seat these (use when he changes tables)"}},
|
||||
["players"])},
|
||||
"unseat_player": {"handler": _unseat_player, "spec": _f(
|
||||
"unseat_player",
|
||||
"Remove a player from the table roster when they bust or leave. Keeps their history.",
|
||||
{"name": {**_S, "description": "Their handle"},
|
||||
"descriptor": {**_S, "description": "Or a description if unnamed"}},
|
||||
[])},
|
||||
"clear_table": {"handler": _clear_table, "spec": _f(
|
||||
"clear_table",
|
||||
"Empty the whole table roster at once — call this when Brian changes tables or says "
|
||||
"to clear the table. The session, stack, and logged reads stay; only who's currently "
|
||||
"seated resets. Then he'll tell you the new table.",
|
||||
{}, [])},
|
||||
"name_villain": {"handler": _name_villain, "spec": _f(
|
||||
"name_villain",
|
||||
"Attach a real name to a player you'd only known by description (e.g. you caught it "
|
||||
"off the Bravo screen). Their whole history carries over to the name.",
|
||||
{"descriptor": {**_S, "description": "How you'd been referring to him, e.g. 'neck tattoo guy'"},
|
||||
"name": {**_S, "description": "His real name/handle"}},
|
||||
["descriptor", "name"])},
|
||||
"link_villains": {"handler": _link_villains, "spec": _f(
|
||||
"link_villains",
|
||||
"Resolve a same-person question when Brian confirms it. same=true MERGES two profiles "
|
||||
"into one (their histories join); same=false records they're DIFFERENT people so you "
|
||||
"stop asking. Only call after he's confirmed — never merge on a guess.",
|
||||
{"player_a": {**_S, "description": "First player, by name or description"},
|
||||
"player_b": {**_S, "description": "Second player, by name or description"},
|
||||
"same": {"type": "boolean", "description": "true = same person (merge); false = different"},
|
||||
"note": {**_S, "description": "For different people: the tell that distinguishes them"}},
|
||||
["player_a", "player_b", "same"])},
|
||||
"end_session": {"handler": _end_session, "spec": _f(
|
||||
"end_session", "Close the live session: record cashout, compute net + hours.",
|
||||
{"cash_out": {**_N, "description": "Final cashout amount"},
|
||||
|
||||
@@ -1,77 +0,0 @@
|
||||
"""Full-fidelity conversation export: interleave what was *said* (chat exchanges)
|
||||
with what Lyra *did* (tool calls) in chronological order.
|
||||
|
||||
The chat only ever lives in SQLite (`exchanges` + `tool_events`); this is the one
|
||||
place that renders a whole session back out as a portable artifact — Markdown for
|
||||
reading / pasting into RTO or another model, JSON for machine reprocessing.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
|
||||
from lyra import clock, memory
|
||||
|
||||
# How roles/actions are labeled in the Markdown transcript.
|
||||
_SPEAKER = {"user": "Brian", "assistant": "Lyra"}
|
||||
|
||||
|
||||
def _merged(session_id: str) -> list[dict]:
|
||||
"""Speech + actions for a session, merged oldest-first by wall-clock time."""
|
||||
events: list[dict] = []
|
||||
for e in memory.history(session_id):
|
||||
events.append({"type": "message", "role": e.role, "content": e.content,
|
||||
"ts": e.created_at})
|
||||
for t in memory.tool_events(session_id):
|
||||
events.append({"type": "tool", "tool": t["tool"], "args": t["args"],
|
||||
"result": t["result"], "ts": t["created_at"]})
|
||||
# created_at is an ISO string; lexicographic sort == chronological sort.
|
||||
events.sort(key=lambda ev: ev["ts"])
|
||||
return events
|
||||
|
||||
|
||||
def _fmt_args(args) -> str:
|
||||
"""Compact one-line rendering of a tool call's arguments."""
|
||||
if isinstance(args, dict):
|
||||
return ", ".join(f"{k}={json.dumps(v, default=str)}" for k, v in args.items())
|
||||
return "" if args is None else str(args)
|
||||
|
||||
|
||||
def as_markdown(session_id: str, name: str | None = None) -> str:
|
||||
events = _merged(session_id)
|
||||
title = name or session_id
|
||||
lines = [f"# Conversation — {title}",
|
||||
f"_Exported {clock.stamp()} · session `{session_id}` · "
|
||||
f"{len(events)} events_", ""]
|
||||
for ev in events:
|
||||
stamp = clock.short(ev["ts"])
|
||||
if ev["type"] == "message":
|
||||
who = _SPEAKER.get(ev["role"], ev["role"].capitalize())
|
||||
lines.append(f"**{who}** · {stamp}")
|
||||
lines.append((ev["content"] or "").rstrip())
|
||||
lines.append("")
|
||||
else:
|
||||
result = (ev["result"] or "").strip().replace("\n", " ")
|
||||
if len(result) > 200:
|
||||
result = result[:197] + "…"
|
||||
lines.append(f" ⚙ `{ev['tool']}({_fmt_args(ev['args'])})` → {result}")
|
||||
lines.append("")
|
||||
return "\n".join(lines).rstrip() + "\n"
|
||||
|
||||
|
||||
def as_json(session_id: str, name: str | None = None) -> dict:
|
||||
return {
|
||||
"session_id": session_id,
|
||||
"name": name,
|
||||
"exported_at": clock.stamp(),
|
||||
"events": _merged(session_id),
|
||||
}
|
||||
|
||||
|
||||
def build(session_id: str, fmt: str = "md", name: str | None = None):
|
||||
"""Return (content_str, media_type, filename) for the requested format."""
|
||||
safe = "".join(c if c.isalnum() or c in "-_" else "_" for c in session_id)[:60]
|
||||
if fmt == "json":
|
||||
body = json.dumps(as_json(session_id, name), indent=2, ensure_ascii=False)
|
||||
return body, "application/json", f"lyra_{safe}.json"
|
||||
body = as_markdown(session_id, name)
|
||||
return body, "text/markdown; charset=utf-8", f"lyra_{safe}.md"
|
||||
+1
-151
@@ -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, thoughts, transcript
|
||||
from lyra import chat, logbus, memory, modes, poker, self_state, summary, thoughts
|
||||
from lyra.llm import Backend
|
||||
|
||||
|
||||
@@ -50,16 +50,6 @@ def _last_user_message(messages: list[dict]) -> str:
|
||||
def create_app() -> FastAPI:
|
||||
app = FastAPI(title="Lyra Web")
|
||||
|
||||
@app.middleware("http")
|
||||
async def _no_stale_shell(request: Request, call_next):
|
||||
"""Always revalidate HTML/JS so a PWA can't serve a stale app shell after a
|
||||
deploy (iOS applies heuristic caching when no cache header is set)."""
|
||||
resp = await call_next(request)
|
||||
ct = resp.headers.get("content-type", "")
|
||||
if "text/html" in ct or "javascript" in ct:
|
||||
resp.headers["Cache-Control"] = "no-cache, must-revalidate"
|
||||
return resp
|
||||
|
||||
@app.get("/_health")
|
||||
async def health() -> dict:
|
||||
return {"ok": True}
|
||||
@@ -72,15 +62,6 @@ def create_app() -> FastAPI:
|
||||
async def get_session(session_id: str) -> list[dict]:
|
||||
return [{"role": ex.role, "content": ex.content} for ex in memory.history(session_id)]
|
||||
|
||||
@app.get("/sessions/{session_id}/export")
|
||||
async def export_session(session_id: str, format: str = "md") -> Response:
|
||||
"""Full transcript — chat + interleaved tool calls — as Markdown or JSON."""
|
||||
name = next((s["name"] for s in memory.list_sessions() if s["id"] == session_id), None)
|
||||
body, media_type, filename = await asyncio.to_thread(
|
||||
transcript.build, session_id, format, name)
|
||||
return Response(content=body, media_type=media_type,
|
||||
headers={"Content-Disposition": f'attachment; filename="{filename}"'})
|
||||
|
||||
@app.post("/sessions/{session_id}")
|
||||
async def save_session(session_id: str, request: Request) -> dict:
|
||||
# Messages are already persisted by chat.respond; just ensure the row exists.
|
||||
@@ -140,109 +121,6 @@ def create_app() -> FastAPI:
|
||||
logbus.log("info", "session edited", id=session_id, fields=list(body))
|
||||
return {"ok": s is not None, "session": s}
|
||||
|
||||
@app.post("/session/stack")
|
||||
async def session_log_stack(request: Request) -> dict:
|
||||
"""Log Brian's current stack directly (no LLM). Server-stamps the time."""
|
||||
body = await request.json()
|
||||
try:
|
||||
amount = float(body.get("amount"))
|
||||
except (TypeError, ValueError):
|
||||
return {"ok": False, "error": "amount must be a number"}
|
||||
note = (body.get("note") or "").strip() or None
|
||||
try:
|
||||
state = await asyncio.to_thread(poker.log_stack, amount, note)
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "stack logged (direct)", amount=amount)
|
||||
return {"ok": True, "stack": state}
|
||||
|
||||
@app.post("/session/buyin")
|
||||
async def session_add_buyin(request: Request) -> dict:
|
||||
"""Add a buy-in/rebuy directly (no LLM)."""
|
||||
body = await request.json()
|
||||
try:
|
||||
amount = float(body.get("amount"))
|
||||
except (TypeError, ValueError):
|
||||
return {"ok": False, "error": "amount must be a number"}
|
||||
try:
|
||||
total = await asyncio.to_thread(poker.add_buyin, amount)
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "buyin added (direct)", amount=amount)
|
||||
return {"ok": True, "buy_in_total": total}
|
||||
|
||||
@app.post("/session")
|
||||
async def session_start(request: Request) -> dict:
|
||||
"""Open a new live session directly (no LLM)."""
|
||||
body = await request.json()
|
||||
sid = await asyncio.to_thread(lambda: poker.start_session(
|
||||
venue=body.get("venue"), stakes=body.get("stakes"),
|
||||
game=body.get("game") or "NLH", fmt=body.get("format") or "cash",
|
||||
buy_in=body.get("buy_in") or 0, mantra=body.get("mantra"),
|
||||
))
|
||||
logbus.log("info", "poker session started (direct)", id=sid)
|
||||
return {"ok": True, "id": sid}
|
||||
|
||||
@app.post("/session/hand")
|
||||
async def session_log_hand(request: Request) -> dict:
|
||||
"""Log a hand directly with flat fields (no LLM parse)."""
|
||||
body = await request.json()
|
||||
try:
|
||||
hid = await asyncio.to_thread(lambda: poker.log_hand(**body))
|
||||
except ValueError as exc:
|
||||
return {"ok": False, "error": str(exc)}
|
||||
logbus.log("info", "hand logged (direct)", id=hid)
|
||||
return {"ok": True, "id": hid}
|
||||
|
||||
@app.patch("/hand/{hand_id}")
|
||||
async def hand_update(hand_id: int, request: Request) -> dict:
|
||||
"""Edit a logged hand's flat fields."""
|
||||
body = await request.json()
|
||||
h = await asyncio.to_thread(lambda: poker.update_hand(hand_id, **body))
|
||||
logbus.log("info", "hand edited", id=hand_id, fields=list(body))
|
||||
return {"ok": h is not None, "hand": h}
|
||||
|
||||
@app.post("/hand/{hand_id}/disown")
|
||||
async def hand_disown(hand_id: int) -> dict:
|
||||
"""Reclassify a hand as observed (not Brian's) — fix a misattributed one."""
|
||||
h = await asyncio.to_thread(poker.disown_hand, hand_id)
|
||||
logbus.log("info", "hand disowned", id=hand_id)
|
||||
return {"ok": h is not None, "hand": h}
|
||||
|
||||
@app.delete("/hand/{hand_id}")
|
||||
async def hand_delete(hand_id: int) -> dict:
|
||||
"""Delete a logged hand."""
|
||||
ok = await asyncio.to_thread(poker.delete_entry, "hand", hand_id)
|
||||
return {"ok": ok}
|
||||
|
||||
@app.post("/session/read")
|
||||
async def session_add_read(request: Request) -> dict:
|
||||
"""Log a read directly (no LLM); upserts the villain file when name is given."""
|
||||
body = await request.json()
|
||||
rid = await asyncio.to_thread(lambda: poker.add_read(
|
||||
note=body.get("note") or "", seat=body.get("seat"), name=body.get("name"),
|
||||
tendencies=body.get("tendencies"), adjustment=body.get("adjustment"),
|
||||
description=body.get("description"), category=body.get("category"),
|
||||
venue=body.get("venue"),
|
||||
))
|
||||
return {"ok": True, "id": rid}
|
||||
|
||||
@app.patch("/player/{player_id}")
|
||||
async def player_update(player_id: int, request: Request) -> dict:
|
||||
"""Edit a player's dossier (rename, fix tendencies). Setting `name` on a
|
||||
nameless (descriptor) villain promotes it to a real handle (named=1)."""
|
||||
body = await request.json()
|
||||
|
||||
def _apply():
|
||||
if body.get("name"):
|
||||
poker.name_villain(player_id, body["name"])
|
||||
rest = {k: v for k, v in body.items() if k != "name"}
|
||||
return poker.update_player(player_id, **rest) # flat row (name included)
|
||||
|
||||
p = await asyncio.to_thread(_apply)
|
||||
logbus.log("info", "player edited", id=player_id, fields=list(body))
|
||||
return {"ok": p is not None, "player": p}
|
||||
|
||||
@app.delete("/session/entry/{kind}/{entry_id}")
|
||||
async def delete_entry(kind: str, entry_id: int) -> dict:
|
||||
"""Delete one HUD entry (hand | stack | read | ritual) by id."""
|
||||
@@ -461,34 +339,6 @@ def create_app() -> FastAPI:
|
||||
async def hands_data(limit: int = 60) -> dict:
|
||||
return {"hands": poker.list_recent_hands(limit=limit)}
|
||||
|
||||
@app.get("/players")
|
||||
async def players_page() -> FileResponse:
|
||||
"""Villain file browser + the identity-resolution review queue."""
|
||||
return FileResponse(str(_STATIC / "players.html"))
|
||||
|
||||
@app.get("/players/data")
|
||||
async def players_data() -> dict:
|
||||
return {"players": poker.players_overview(),
|
||||
"queue": poker.list_identity_queue()}
|
||||
|
||||
@app.get("/player/{player_id}/data")
|
||||
async def player_data(player_id: int) -> dict:
|
||||
return poker.villain_recall(player_id) or {}
|
||||
|
||||
@app.post("/identity/{task_id}/resolve")
|
||||
async def identity_resolve(task_id: int, request: Request) -> dict:
|
||||
body = await request.json()
|
||||
action = body.get("action") or "dismiss"
|
||||
kw = {k: v for k, v in body.items() if k != "action"}
|
||||
ok = await asyncio.to_thread(poker.resolve_identity_task, task_id, action, **kw)
|
||||
logbus.log("info", "identity task resolved", id=task_id, action=action)
|
||||
return {"ok": ok}
|
||||
|
||||
@app.post("/players/scan")
|
||||
async def players_scan() -> dict:
|
||||
filed = await asyncio.to_thread(poker.scan_merge_candidates)
|
||||
return {"ok": True, "filed": filed}
|
||||
|
||||
@app.get("/recap/{session_id}")
|
||||
async def recap_page() -> FileResponse:
|
||||
return FileResponse(str(_STATIC / "recap.html"))
|
||||
|
||||
@@ -282,54 +282,8 @@
|
||||
const h = await r.json();
|
||||
if(!h || !h.id){ document.getElementById('root').innerHTML='<p class="err">Hand not found.</p>'; return; }
|
||||
render(h);
|
||||
renderEditor(h);
|
||||
}catch(e){ document.getElementById('root').innerHTML='<p class="err">Couldn\'t load the hand.</p>'; }
|
||||
}
|
||||
|
||||
function renderEditor(h){
|
||||
const wrap = document.createElement('div');
|
||||
wrap.style.cssText = 'max-width:520px;margin:18px auto 0;border-top:1px solid #241a10;padding-top:12px;';
|
||||
const tags = ['','well_played','leak','cooler','confidence','notable'];
|
||||
wrap.innerHTML = `
|
||||
<details style="font-size:.9rem;">
|
||||
<summary style="cursor:pointer;color:var(--accent,#ff7a00);">✎ Edit this hand</summary>
|
||||
<div style="display:flex;flex-direction:column;gap:8px;margin-top:10px;">
|
||||
<label>Position <input id="e_pos" value="${esc(h.position||'')}" placeholder="e.g. CO (blank if not yours)"></label>
|
||||
<label>Your cards <input id="e_hole" value="${esc(h.hole_cards||'')}" placeholder="e.g. As Ks (blank if not yours)"></label>
|
||||
<label>Board <input id="e_board" value="${esc(h.board||'')}" placeholder="e.g. Tc 8s Js 6d"></label>
|
||||
<label>Your net <input id="e_res" value="${h.result!=null?esc(h.result):''}" placeholder="+ / − chips (blank if not yours)"></label>
|
||||
<label>Tag <select id="e_tag">${tags.map(t=>`<option value="${t}" ${h.tag===t?'selected':''}>${t||'—'}</option>`).join('')}</select></label>
|
||||
<label>Lesson <input id="e_lesson" value="${esc(h.lesson||'')}"></label>
|
||||
<div style="display:flex;flex-wrap:wrap;gap:8px;margin-top:4px;">
|
||||
<button onclick="saveHand(${h.id})" style="border-color:var(--accent,#ff7a00);color:var(--accent,#ff7a00);">Save</button>
|
||||
<button onclick="disown(${h.id})" title="It was someone else's hand — clear it from you">Not my hand</button>
|
||||
<button onclick="delHand(${h.id})" style="margin-left:auto;color:#ff6b6b;">Delete</button>
|
||||
</div>
|
||||
</div>
|
||||
</details>`;
|
||||
wrap.querySelectorAll('input,select').forEach(el=>{el.style.cssText='font:inherit;font-size:.86rem;padding:5px 8px;border-radius:6px;border:1px solid #241a10;background:#0b0b0b;color:#e8e8e8;margin-left:8px;';});
|
||||
wrap.querySelectorAll('label').forEach(el=>{el.style.cssText='display:flex;justify-content:space-between;align-items:center;color:#8a8a8a;';});
|
||||
wrap.querySelectorAll('button').forEach(el=>{el.style.cssText+=';font:inherit;font-size:.84rem;padding:6px 12px;border-radius:7px;border:1px solid #241a10;background:#141414;color:#e8e8e8;cursor:pointer;';});
|
||||
document.getElementById('root').appendChild(wrap);
|
||||
}
|
||||
const val = id => document.getElementById(id).value.trim();
|
||||
async function saveHand(id){
|
||||
const body = {position:val('e_pos'), hole_cards:val('e_hole'), board:val('e_board'),
|
||||
tag:val('e_tag'), lesson:val('e_lesson')};
|
||||
const res = val('e_res'); if(res!=='') body.result = Number(res);
|
||||
await fetch(`/hand/${id}`,{method:'PATCH',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
|
||||
load();
|
||||
}
|
||||
async function disown(id){
|
||||
if(!confirm("Mark this as someone else's hand? It'll be cleared from your stats.")) return;
|
||||
await fetch(`/hand/${id}/disown`,{method:'POST'});
|
||||
load();
|
||||
}
|
||||
async function delHand(id){
|
||||
if(!confirm('Delete this hand for good?')) return;
|
||||
await fetch(`/hand/${id}`,{method:'DELETE'});
|
||||
location.href='/hands';
|
||||
}
|
||||
load();
|
||||
</script>
|
||||
<script src="/nav.js"></script>
|
||||
|
||||
@@ -3,14 +3,14 @@
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<title>Lyra Core Chat</title>
|
||||
<link rel="stylesheet" href="style.css?v=8" />
|
||||
<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="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="#141414" />
|
||||
<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" />
|
||||
@@ -88,7 +88,6 @@
|
||||
<select id="sessions"></select>
|
||||
<button id="newSessionBtn">➕ New</button>
|
||||
<button id="renameSessionBtn">✏️ Rename</button>
|
||||
<button id="exportSessionBtn" title="Download full transcript (chat + tool calls)">⬇ Export</button>
|
||||
<button id="thinkingStreamBtn" title="Show live activity log">📜 Live Log</button>
|
||||
</div>
|
||||
|
||||
@@ -125,12 +124,6 @@
|
||||
<button id="sendBtn" aria-label="Send" title="Send (or ⌘/Ctrl+Enter)">↑</button>
|
||||
</div>
|
||||
|
||||
<!-- Stack quick-capture (no LLM): type a number -> logs current stack -->
|
||||
<div id="stackQuick">
|
||||
<input id="stackQuickInput" type="number" inputmode="decimal" placeholder="Stack $" aria-label="Log current stack">
|
||||
<button id="stackQuickBtn" type="button" title="Log stack (no chat)">Log</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>
|
||||
@@ -216,72 +209,6 @@
|
||||
const API_URL = `${RELAY_BASE}/v1/chat/completions`;
|
||||
const STREAM_URL = `${RELAY_BASE}/v1/chat/stream`;
|
||||
|
||||
// Stack quick-capture (no LLM): type a number -> POST /session/stack.
|
||||
function stackQuickLog() {
|
||||
const el = document.getElementById("stackQuickInput");
|
||||
if (!el) return;
|
||||
const raw = (el.value || "").replace(/[^0-9.]/g, "");
|
||||
if (!raw) return;
|
||||
const amount = Number(raw);
|
||||
const content = document.getElementById("thinkingContent");
|
||||
const empty = document.getElementById("thinkingEmpty");
|
||||
fetch("/session/stack", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ amount })
|
||||
}).then(r => r.json()).then(data => {
|
||||
if (empty && empty.parentNode) empty.parentNode.removeChild(empty);
|
||||
const line = document.createElement("div");
|
||||
const t = new Date().toLocaleTimeString();
|
||||
if (!data.ok) {
|
||||
line.className = "log-line log-error";
|
||||
line.textContent = "⚠ " + (data.error || "stack not logged");
|
||||
} else {
|
||||
line.className = "log-line log-info";
|
||||
const net = (data.stack && data.stack.net != null)
|
||||
? " (net " + (data.stack.net >= 0 ? "+" : "") + data.stack.net + ")" : "";
|
||||
line.textContent = t + " 💰 $" + amount + " logged" + net;
|
||||
el.value = "";
|
||||
}
|
||||
if (content) { content.appendChild(line); content.scrollTop = content.scrollHeight; }
|
||||
}).catch(e => {
|
||||
if (content) {
|
||||
const line = document.createElement("div");
|
||||
line.className = "log-line log-error";
|
||||
line.textContent = "⚠ stack log failed: " + e.message;
|
||||
content.appendChild(line);
|
||||
}
|
||||
});
|
||||
}
|
||||
// Only show the stack quick-logger when a poker session is actually live —
|
||||
// otherwise logging just errors ("no live session").
|
||||
function updateStackQuickVisibility() {
|
||||
const box = document.getElementById("stackQuick");
|
||||
if (!box) return;
|
||||
fetch("/session/data", { cache: "no-store" })
|
||||
.then(function (r) { return r.json(); })
|
||||
.then(function (data) {
|
||||
const live = !!(data && data.session && data.session.is_live);
|
||||
box.style.display = live ? "flex" : "none";
|
||||
})
|
||||
.catch(function () { box.style.display = "none"; });
|
||||
}
|
||||
(function wireStackQuick() {
|
||||
const box = document.getElementById("stackQuick");
|
||||
const btn = document.getElementById("stackQuickBtn");
|
||||
const inp = document.getElementById("stackQuickInput");
|
||||
if (box) box.style.display = "none"; // hidden until a live session is confirmed
|
||||
if (btn) btn.addEventListener("click", stackQuickLog);
|
||||
if (inp) inp.addEventListener("keydown", function (e) {
|
||||
if (e.key === "Enter") { e.preventDefault(); stackQuickLog(); }
|
||||
});
|
||||
updateStackQuickVisibility();
|
||||
setInterval(updateStackQuickVisibility, 10000);
|
||||
document.addEventListener("visibilitychange", function () {
|
||||
if (!document.hidden) updateStackQuickVisibility();
|
||||
});
|
||||
})();
|
||||
|
||||
function generateSessionId() {
|
||||
return "sess-" + Math.random().toString(36).substring(2, 10);
|
||||
}
|
||||
@@ -774,16 +701,6 @@
|
||||
window.addEventListener("resize", nudgeAppHeight);
|
||||
window.addEventListener("orientationchange", nudgeAppHeight);
|
||||
|
||||
// A rotation reflows the chat and iOS drops the scroll to mid-history. If we
|
||||
// were pinned to the latest message, snap back there once the layout settles
|
||||
// (re-fire across the reflow since iOS reports stale dimensions mid-rotate).
|
||||
window.addEventListener("orientationchange", () => {
|
||||
const m = document.getElementById("messages");
|
||||
const wasAtBottom = m.scrollHeight - m.scrollTop - m.clientHeight < 90;
|
||||
if (!wasAtBottom) return; // respect the user's scroll-up position
|
||||
[100, 300, 600].forEach((t) => setTimeout(() => { m.scrollTop = m.scrollHeight; }, t));
|
||||
});
|
||||
|
||||
// Keep the latest message in view when the keyboard opens/closes.
|
||||
const userInputEl = document.getElementById("userInput");
|
||||
userInputEl.addEventListener("focus", () => {
|
||||
@@ -988,19 +905,6 @@
|
||||
addMessage("system", `Session renamed to: ${newName}`);
|
||||
});
|
||||
|
||||
document.getElementById("exportSessionBtn").addEventListener("click", () => {
|
||||
if (!currentSession) { addMessage("system", "No session to export."); return; }
|
||||
const fmt = window.confirm("Export as Markdown? (Cancel = JSON)") ? "md" : "json";
|
||||
// Hitting the download endpoint navigates a hidden anchor so the browser
|
||||
// saves the file (chat + interleaved tool calls) instead of rendering it.
|
||||
const a = document.createElement("a");
|
||||
a.href = `${RELAY_BASE}/sessions/${encodeURIComponent(currentSession)}/export?format=${fmt}`;
|
||||
a.download = "";
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
a.remove();
|
||||
});
|
||||
|
||||
// Settings Modal
|
||||
const settingsModal = document.getElementById("settingsModal");
|
||||
const settingsBtn = document.getElementById("settingsBtn");
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
{ href: "/session", icon: "♠", label: "Session" },
|
||||
{ href: "/history", icon: "📚", label: "History" },
|
||||
{ href: "/hands", icon: "🃏", label: "Hands" },
|
||||
{ href: "/players", icon: "👤", label: "Players" },
|
||||
{ href: "/self", icon: "🧠", label: "Mind" },
|
||||
{ href: "/thoughts", icon: "💭", label: "Thoughts" },
|
||||
{ href: "/journal", icon: "📔", label: "Journal" },
|
||||
|
||||
@@ -1,166 +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 — Players</title>
|
||||
<style>
|
||||
:root{--bg:#070707;--bg-elev:#0e0e0e;--bg-line:#141414;--border:#2a1d12;--text:#e8e8e8;--fade:#8a8a8a;--accent:#ff7a00;}
|
||||
*{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 44px;}
|
||||
h2.sec{font-size:.74rem;text-transform:uppercase;letter-spacing:.6px;color:var(--fade);margin:20px 2px 8px;}
|
||||
.queue{background:#160d05;border:1px solid var(--accent);border-radius:10px;padding:11px 12px;margin-bottom:9px;}
|
||||
.queue .k{font-size:.62rem;text-transform:uppercase;letter-spacing:.5px;color:var(--accent);}
|
||||
.queue .q-body{font-size:.9rem;margin:5px 0 9px;}
|
||||
.queue .who{font-weight:600;}
|
||||
.btns{display:flex;flex-wrap:wrap;gap:7px;}
|
||||
button{font:inherit;font-size:.82rem;padding:6px 11px;border-radius:7px;border:1px solid var(--border);
|
||||
background:var(--bg-line);color:var(--text);cursor:pointer;}
|
||||
button.pri{border-color:var(--accent);color:var(--accent);}
|
||||
button:active{background:#241400;}
|
||||
.card{background:var(--bg-elev);border:1px solid var(--border);border-radius:10px;padding:10px 12px;margin-bottom:8px;}
|
||||
.card .row{display:flex;align-items:center;gap:9px;cursor:pointer;}
|
||||
.nm{font-size:.96rem;font-weight:600;}
|
||||
.nm.desc{font-weight:500;font-style:italic;color:#e8d3bf;}
|
||||
.meta{font-size:.74rem;color:var(--fade);}
|
||||
.pill{font-size:.6rem;text-transform:uppercase;letter-spacing:.4px;border:1px solid var(--border);
|
||||
border-radius:20px;padding:1px 7px;color:var(--fade);}
|
||||
.pill.desc{border-color:#5a3c1e;color:#d0a56e;}
|
||||
.spacer{margin-left:auto;}
|
||||
.detail{margin-top:9px;padding-top:9px;border-top:1px solid var(--bg-line);font-size:.86rem;display:none;}
|
||||
.detail.open{display:block;}
|
||||
.detail .lbl{color:var(--fade);font-size:.72rem;text-transform:uppercase;letter-spacing:.4px;margin:8px 0 3px;}
|
||||
.detail ul{margin:3px 0;padding-left:18px;} .detail li{margin:2px 0;}
|
||||
.detail a{color:var(--accent);text-decoration:none;}
|
||||
.edit{display:flex;flex-wrap:wrap;gap:6px;margin-top:9px;}
|
||||
.edit input,.edit select{font:inherit;font-size:.82rem;padding:5px 8px;border-radius:6px;
|
||||
border:1px solid var(--border);background:var(--bg);color:var(--text);}
|
||||
.empty{color:var(--fade);text-align:center;padding:34px 16px;}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<div class="topbar">
|
||||
<h1>👤 Players</h1>
|
||||
<a class="back" href="/">← Chat</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;}
|
||||
let DATA={players:[],queue:[]};
|
||||
|
||||
async function load(){
|
||||
try{ DATA=await (await fetch('/players/data',{cache:'no-store'})).json(); }
|
||||
catch(e){ document.getElementById('root').innerHTML='<p class="empty">Couldn\'t load players.</p>'; return; }
|
||||
render();
|
||||
}
|
||||
|
||||
function render(){
|
||||
const {players,queue}=DATA;
|
||||
const named=players.filter(p=>p.named), nameless=players.filter(p=>!p.named);
|
||||
document.getElementById('count').textContent=`${players.length} player${players.length===1?'':'s'}`;
|
||||
let html='';
|
||||
|
||||
if(queue.length){
|
||||
html+=`<h2 class="sec">⚠ Needs your call — ${queue.length}</h2>`;
|
||||
html+=queue.map(qCard).join('');
|
||||
}
|
||||
html+=`<h2 class="sec">Named — ${named.length} <button class="pri" style="float:right;padding:3px 9px" onclick="scan()">Scan for dupes</button></h2>`;
|
||||
html+= named.length ? named.map(pCard).join('') : '<p class="empty">No named players yet.</p>';
|
||||
html+=`<h2 class="sec">By description — ${nameless.length}</h2>`;
|
||||
html+= nameless.length ? nameless.map(pCard).join('') : '<p class="empty">No nameless villains yet — they show up here as you describe players at the table.</p>';
|
||||
document.getElementById('root').innerHTML=html;
|
||||
}
|
||||
|
||||
function qCard(q){
|
||||
const ps=q.players||[];
|
||||
if(q.kind==='merge_candidate' && ps.length===2){
|
||||
const a=ps[0], b=ps[1];
|
||||
return `<div class="queue"><div class="k">Possible merge${q.confidence?` · ${Math.round(q.confidence*100)}%`:''}</div>
|
||||
<div class="q-body">Same person? <span class="who">${label(a)}</span> vs <span class="who">${label(b)}</span></div>
|
||||
<div class="btns">
|
||||
<button class="pri" onclick="resolveTask(${q.id},'merge',{keep_id:${keepId(a,b)},dup_id:${dupId(a,b)}})">✓ Same — merge</button>
|
||||
<button onclick="resolveTask(${q.id},'distinct',{a_id:${a.id},b_id:${b.id}})">✕ Different</button>
|
||||
<button onclick="resolveTask(${q.id},'dismiss',{})">Dismiss</button>
|
||||
</div></div>`;
|
||||
}
|
||||
const who=ps[0]?label(ps[0]):'?';
|
||||
return `<div class="queue"><div class="k">Needs clarification</div>
|
||||
<div class="q-body">You referred to <span class="who">“${esc(q.descriptor||'')}”</span>${ps[0]?` — is that ${who}?`:''}</div>
|
||||
<div class="btns"><button onclick="resolveTask(${q.id},'dismiss',{})">Got it</button></div></div>`;
|
||||
}
|
||||
const label=p=>`${esc(p.name)}${p.named?'':' <span class="pill desc">desc</span>'}${p.venue?` · ${esc(p.venue)}`:''}${p.obs?` · ${p.obs}h`:''}`;
|
||||
const keepId=(a,b)=>a.named?a.id:(b.named?b.id:a.id);
|
||||
const dupId=(a,b)=>a.named?b.id:(b.named?a.id:b.id);
|
||||
|
||||
function pCard(p){
|
||||
const pills=[p.named?'':'<span class="pill desc">desc</span>',p.category?`<span class="pill">${esc(p.category)}</span>`:''].join('');
|
||||
const meta=[p.venue,p.obs?`${p.obs} hands`:'',p.reads?`${p.reads} reads`:''].filter(Boolean).join(' · ');
|
||||
return `<div class="card" id="p${p.id}">
|
||||
<div class="row" onclick="toggle(${p.id})">
|
||||
<span class="nm ${p.named?'':'desc'}">${p.named?esc(p.name):'“'+esc(p.name)+'”'}</span>
|
||||
${pills}<span class="spacer"></span><span class="meta">${esc(meta)}</span>
|
||||
</div>
|
||||
<div class="detail" id="d${p.id}"></div></div>`;
|
||||
}
|
||||
|
||||
async function toggle(id){
|
||||
const el=document.getElementById('d'+id);
|
||||
if(el.classList.contains('open')){el.classList.remove('open');return;}
|
||||
el.classList.add('open'); el.innerHTML='<span class="meta">Loading…</span>';
|
||||
const r=await (await fetch(`/player/${id}/data`,{cache:'no-store'})).json();
|
||||
el.innerHTML=detailHtml(id,r);
|
||||
}
|
||||
|
||||
function detailHtml(id,r){
|
||||
const p=r.player||{}; let h='';
|
||||
const seen=[r.times_seen?`seen ${r.times_seen}×`:'', r.last_seen?`last ${String(r.last_seen).slice(0,10)}`:''].filter(Boolean).join(' · ');
|
||||
if(seen) h+=`<div class="meta">${esc(seen)}</div>`;
|
||||
if(r.stats) h+=`<div class="lbl">Stats</div><div>VPIP ${r.stats.vpip_pct} · PFR ${r.stats.pfr_pct} · WTSD ${r.stats.wtsd_pct} <span class="meta">(${r.stats.hands} hands)</span></div>`;
|
||||
if(r.descriptors) h+=`<div class="lbl">Descriptors</div><div>${esc(r.descriptors)}</div>`;
|
||||
if(p.tendencies) h+=`<div class="lbl">Tendencies</div><div>${esc(p.tendencies)}</div>`;
|
||||
if(p.adjustment) h+=`<div class="lbl">Exploit</div><div>${esc(p.adjustment)}</div>`;
|
||||
if((r.reads||[]).length){h+='<div class="lbl">Reads</div><ul>'+r.reads.slice(0,8).map(x=>`<li>${esc(x)}</li>`).join('')+'</ul>';}
|
||||
if((r.notable_hands||[]).length){h+='<div class="lbl">Notable hands</div><ul>'+r.notable_hands.map(x=>`<li><a href="/hand/${x.hand_id}">hand #${x.hand_id}</a>${x.cards?' — '+esc(x.cards):''}${x.summary?' <span class="meta">'+esc(x.summary)+'</span>':''}</li>`).join('')+'</ul>';}
|
||||
h+=`<div class="edit">
|
||||
${p.named?'':`<input id="nm${id}" placeholder="give a name…" size="12"><button onclick="rename(${id})">Name</button>`}
|
||||
<select id="cat${id}" onchange="setCat(${id})">
|
||||
${['','feeder','risky','reg','unknown'].map(c=>`<option value="${c}" ${p.category===c?'selected':''}>${c||'category…'}</option>`).join('')}
|
||||
</select></div>`;
|
||||
return h;
|
||||
}
|
||||
|
||||
async function rename(id){
|
||||
const v=document.getElementById('nm'+id).value.trim(); if(!v)return;
|
||||
await fetch(`/player/${id}`,{method:'PATCH',headers:{'Content-Type':'application/json'},body:JSON.stringify({name:v})});
|
||||
load();
|
||||
}
|
||||
async function setCat(id){
|
||||
const v=document.getElementById('cat'+id).value;
|
||||
await fetch(`/player/${id}`,{method:'PATCH',headers:{'Content-Type':'application/json'},body:JSON.stringify({category:v})});
|
||||
}
|
||||
async function resolveTask(id,action,kw){
|
||||
await fetch(`/identity/${id}/resolve`,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action,...kw})});
|
||||
load();
|
||||
}
|
||||
async function scan(){
|
||||
const r=await (await fetch('/players/scan',{method:'POST'})).json();
|
||||
load();
|
||||
}
|
||||
load();
|
||||
</script>
|
||||
<script src="/nav.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -104,26 +104,6 @@
|
||||
.big-empty { text-align: center; padding: 50px 20px; color: var(--fade); }
|
||||
.big-empty .ico { font-size: 2.4rem; }
|
||||
.big-empty a { color: var(--accent); text-decoration: none; }
|
||||
/* running timeline */
|
||||
ul.tl { list-style: none; margin: 0; padding: 0; }
|
||||
ul.tl li { display: flex; gap: 10px; padding: 8px 0; border-bottom: 1px solid var(--bg-line); align-items: baseline; font-size: .92rem; line-height: 1.4; }
|
||||
ul.tl li:last-child { border-bottom: none; }
|
||||
.tl-time { color: var(--fade); font-variant-numeric: tabular-nums; font-size: .78rem; min-width: 60px; flex: none; }
|
||||
.tl-body { flex: 1; }
|
||||
.tl-amt { margin-left: 6px; font-variant-numeric: tabular-nums; }
|
||||
li.start .tl-body { color: var(--accent); font-weight: 600; }
|
||||
li.scar .tl-body, li.confidence .tl-body { font-style: italic; }
|
||||
.tl-body a.hand { color: var(--accent); text-decoration: none; white-space: nowrap; }
|
||||
/* quick-capture (no LLM) + inline correction controls */
|
||||
.quick { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 14px; }
|
||||
.quick input { width: 100px; background: var(--bg-line); border: 1px solid var(--border);
|
||||
border-radius: 8px; padding: 8px 10px; color: var(--text); }
|
||||
.quick input:focus { outline: none; border-color: var(--accent); }
|
||||
.quick button { background: var(--accent); color: #0a0a0a; border: 1px solid var(--accent);
|
||||
border-radius: 8px; padding: 8px 12px; cursor: pointer; font-weight: 600; }
|
||||
button.mini { background: none; border: none; color: var(--fade); cursor: pointer;
|
||||
font-size: .9rem; padding: 0 6px; }
|
||||
button.mini:active { color: var(--accent); }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
@@ -227,30 +207,6 @@
|
||||
} catch(e){ alert('Delete failed: '+e.message); }
|
||||
}
|
||||
|
||||
// Quick-capture (no LLM): post a number to a direct endpoint, then refresh.
|
||||
function numVal(id){ const el = document.getElementById(id); return Number(((el && el.value) || '').replace(/[^0-9.]/g,'')); }
|
||||
async function postQuick(url, amount){
|
||||
const r = await fetch(url, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ amount }) });
|
||||
const d = await r.json();
|
||||
if(!d.ok){ alert(d.error || 'failed'); return false; }
|
||||
return true;
|
||||
}
|
||||
async function postStack(){ const v = numVal('qStack'); if(v && await postQuick('/session/stack', v)){ document.getElementById('qStack').value=''; refresh(); } }
|
||||
async function postBuyin(){ const v = numVal('qBuyin'); if(v && await postQuick('/session/buyin', v)){ document.getElementById('qBuyin').value=''; refresh(); } }
|
||||
async function postCashout(){
|
||||
if(!curSession) return;
|
||||
const v = numVal('qCashout'); if(!v) return;
|
||||
const r = await fetch('/session/'+curSession.id, { method:'PATCH', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ cash_out: v }) });
|
||||
if(!(await r.json()).ok){ alert('failed'); return; }
|
||||
document.getElementById('qCashout').value=''; refresh();
|
||||
}
|
||||
async function renamePlayer(id, current){
|
||||
const name = prompt('Rename player', current || ''); if(!name) return;
|
||||
const r = await fetch('/player/'+id, { method:'PATCH', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ name }) });
|
||||
if(!(await r.json()).ok){ alert('failed'); return; }
|
||||
refresh();
|
||||
}
|
||||
|
||||
function render(data){
|
||||
const s = data.session;
|
||||
if (!s) {
|
||||
@@ -263,9 +219,7 @@
|
||||
}
|
||||
curSession = s;
|
||||
const stack = data.stack || {};
|
||||
const timeline = data.timeline || [];
|
||||
const hands = data.hands || [];
|
||||
const roster = data.roster || [];
|
||||
const villains = data.villains || [];
|
||||
const notes = data.notes || [];
|
||||
const stats = data.stats || {};
|
||||
@@ -320,25 +274,7 @@
|
||||
<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 — log it below or tell Lyra ("I\'m at 350").</p>' : ''}
|
||||
<div class="quick">
|
||||
<input id="qStack" type="number" inputmode="decimal" placeholder="Stack $" onkeydown="if(event.key==='Enter')postStack()">
|
||||
<button onclick="postStack()">Log stack</button>
|
||||
<input id="qBuyin" type="number" inputmode="decimal" placeholder="Buy-in $" onkeydown="if(event.key==='Enter')postBuyin()">
|
||||
<button onclick="postBuyin()">Add buy-in</button>
|
||||
<input id="qCashout" type="number" inputmode="decimal" placeholder="Cash out $" onkeydown="if(event.key==='Enter')postCashout()">
|
||||
<button onclick="postCashout()">Cash out</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<p class="label">📜 Timeline</p>
|
||||
${timeline.length ? `<ul class="tl">${timeline.map(e => `
|
||||
<li class="${esc(e.kind)}">
|
||||
<span class="tl-time">${esc(e.time)}</span>
|
||||
<span class="tl-body">${esc(e.text)}${e.amount != null ? ` <b class="tl-amt">${money(e.amount)}</b>` : ''}${e.result != null ? ` <span class="res ${e.result>=0?'up':'down'}">${signed(e.result)}</span>` : ''}${e.hand_id ? ` <a class="hand" href="/hand/${e.hand_id}">hand ›</a>` : ''}</span>
|
||||
</li>`).join('')}</ul>`
|
||||
: '<p class="empty">Nothing yet tonight — the running log fills in as you play.</p>'}
|
||||
${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">
|
||||
@@ -370,25 +306,11 @@
|
||||
: '<p class="empty">No scars logged — mistakes to study land here.</p>'}
|
||||
</div>
|
||||
|
||||
<div class="card">
|
||||
<p class="label">🪑 Table (${roster.length})</p>
|
||||
${roster.length ? `<ul class="rows">${roster.map(v => `
|
||||
<li class="villain">
|
||||
${v.seat ? `<span class="cat">${esc(v.seat)}</span> ` : ''}<b>${esc(v.name)}</b>
|
||||
${v.category ? `<span class="cat">[${esc(v.category)}]</span>` : ''}
|
||||
${v.reads ? `<span class="cat">· ${v.reads} read${v.reads===1?'':'s'}</span>` : ''}
|
||||
<button class="mini" title="Rename / fix" onclick="renamePlayer(${v.id}, '${esc(v.name||'').replace(/'/g,"\\'")}')">✎</button>
|
||||
${v.last_note ? `<div class="note-meta">“${esc(v.last_note)}”</div>` : ''}
|
||||
</li>`).join('')}</ul>`
|
||||
: '<p class="empty">No roster yet — tell Lyra who is at the table.</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>` : ''}
|
||||
<button class="mini" title="Rename / fix" onclick="renamePlayer(${v.id}, '${esc(v.name||'').replace(/'/g,"\\'")}')">✎</button>
|
||||
${v.tendencies ? `<div>${esc(v.tendencies)}</div>` : ''}
|
||||
${v.last_note ? `<div class="note-meta">“${esc(v.last_note)}”</div>` : ''}
|
||||
</li>`).join('')}</ul>`
|
||||
|
||||
@@ -56,16 +56,6 @@ body.dark {
|
||||
|
||||
html {
|
||||
overscroll-behavior: none;
|
||||
/* Stop iOS from inflating font sizes when the device rotates to landscape (and
|
||||
leaving them big on rotate back). Every other page sets this; the chat didn't. */
|
||||
-webkit-text-size-adjust: 100%;
|
||||
text-size-adjust: 100%;
|
||||
}
|
||||
|
||||
html {
|
||||
/* Paints the iOS home-indicator strip below the dvh shell; match the tab bar so the
|
||||
bar looks like it continues to the physical bottom edge. */
|
||||
background: var(--bg-line);
|
||||
}
|
||||
|
||||
body {
|
||||
@@ -836,17 +826,15 @@ select:hover {
|
||||
@media screen and (max-width: 768px) {
|
||||
body {
|
||||
padding: 0;
|
||||
background: var(--bg-line); /* matches the tab bar so any strip below #chat is seamless */
|
||||
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: 100vh; /* fallback for old browsers */
|
||||
height: 100dvh; /* the *visible* viewport — keep all content (incl. the tab bar)
|
||||
inside what iOS actually paints, so nothing is clipped into the
|
||||
home-indicator dead zone. The strip below is matched in color. */
|
||||
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);
|
||||
border-radius: 0;
|
||||
border: none;
|
||||
@@ -930,11 +918,8 @@ select:hover {
|
||||
display: flex;
|
||||
flex: none; /* never let it be compressed/clipped by the flex column */
|
||||
border-top: 1px solid var(--border);
|
||||
background: var(--bg-line); /* lighter than the page so it reads as a solid bar */
|
||||
/* Shell is 100dvh, so the bar sits at the bottom of the rendered area with the icons
|
||||
fully visible. Minimal padding keeps them low; the home-indicator strip just below
|
||||
the rendered area is painted the same color (html bg) so the bar looks continuous. */
|
||||
padding-bottom: 4px;
|
||||
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);
|
||||
}
|
||||
@@ -1242,31 +1227,3 @@ select:hover {
|
||||
scroll-behavior: auto !important;
|
||||
}
|
||||
}
|
||||
|
||||
/* Stack quick-capture (2nd input box on the chat page) — logs without the LLM. */
|
||||
#stackQuick {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
align-items: center;
|
||||
padding: 6px 12px;
|
||||
border-top: 1px solid var(--border);
|
||||
background: var(--bg-panel);
|
||||
}
|
||||
#stackQuick input {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
padding: 8px 10px;
|
||||
background: var(--bg-elev);
|
||||
color: inherit;
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 8px;
|
||||
}
|
||||
#stackQuick button {
|
||||
padding: 8px 14px;
|
||||
background: var(--accent);
|
||||
color: #000;
|
||||
border: none;
|
||||
border-radius: 8px;
|
||||
font-weight: 600;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
"""Decision log (Decide mode's learning layer): log -> resolve -> recall, + tools."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mem(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
# Deterministic, content-dependent embeddings so recall ordering is meaningful:
|
||||
# "cleveland"/"tournament" cluster on axis 0, "stocks"/"money" on axis 1.
|
||||
def fake_embed(texts):
|
||||
out = []
|
||||
for t in texts:
|
||||
t = t.lower()
|
||||
poker = sum(w in t for w in ("tournament", "cleveland", "poker", "buy-in"))
|
||||
money = sum(w in t for w in ("stocks", "money", "invest", "sell"))
|
||||
out.append([float(poker), float(money), 0.1])
|
||||
return out
|
||||
monkeypatch.setattr(llm, "embed", fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
return memory
|
||||
|
||||
|
||||
def test_log_and_get_roundtrip(mem):
|
||||
did = mem.log_decision(
|
||||
situation="Play the Cleveland turbo tournament tomorrow?",
|
||||
choice="Yes, but only the noon flight",
|
||||
options="skip it / noon flight / both flights",
|
||||
rationale="20-min levels suit my aggression; one flight caps the variance",
|
||||
confidence=4, tags="poker,tournament",
|
||||
)
|
||||
d = mem.get_decision(did)
|
||||
assert d.situation.startswith("Play the Cleveland")
|
||||
assert d.choice == "Yes, but only the noon flight"
|
||||
assert d.confidence == 4 and d.tags == "poker,tournament"
|
||||
assert not d.resolved and d.outcome is None
|
||||
|
||||
|
||||
def test_resolve_closes_the_loop(mem):
|
||||
did = mem.log_decision(situation="Sell the stocks now?", choice="Hold")
|
||||
assert mem.resolve_decision(did, "Recovered 12% the next week", outcome_rating=1)
|
||||
d = mem.get_decision(did)
|
||||
assert d.resolved and d.outcome_rating == 1
|
||||
assert "Recovered" in d.outcome and d.resolved_at is not None
|
||||
|
||||
|
||||
def test_resolve_unknown_id_is_false(mem):
|
||||
assert mem.resolve_decision(999, "n/a") is False
|
||||
|
||||
|
||||
def test_list_open_only_filters_resolved(mem):
|
||||
a = mem.log_decision(situation="A?", choice="x")
|
||||
mem.log_decision(situation="B?", choice="y")
|
||||
mem.resolve_decision(a, "done", 0)
|
||||
assert {d.situation for d in mem.list_decisions(open_only=True)} == {"B?"}
|
||||
assert len(mem.list_decisions()) == 2
|
||||
|
||||
|
||||
def test_recall_ranks_by_similarity(mem):
|
||||
mem.log_decision(situation="Which Cleveland tournament flight?", choice="noon")
|
||||
mem.log_decision(situation="Should I sell the stocks?", choice="hold")
|
||||
hits = mem.recall_decisions("another poker tournament buy-in", k=2)
|
||||
assert hits[0].situation.startswith("Which Cleveland") # poker cluster ranks first
|
||||
assert hits[0].score >= hits[1].score
|
||||
|
||||
|
||||
# --- tool layer ---------------------------------------------------------------
|
||||
|
||||
def test_log_decision_tool_persists(mem):
|
||||
from lyra import tools
|
||||
out = tools.dispatch("log_decision",
|
||||
{"situation": "Move the MI50 to auto clocks?", "choice": "yes",
|
||||
"confidence": "3", "tags": "build"})
|
||||
assert "#1" in out
|
||||
d = mem.get_decision(1)
|
||||
assert d.choice == "yes" and d.confidence == 3 and d.tags == "build"
|
||||
|
||||
|
||||
def test_log_decision_tool_requires_both_fields(mem):
|
||||
from lyra import tools
|
||||
assert "Need both" in tools.dispatch("log_decision", {"situation": "just this"})
|
||||
|
||||
|
||||
def test_resolve_decision_tool(mem):
|
||||
from lyra import tools
|
||||
did = mem.log_decision(situation="X?", choice="y")
|
||||
out = tools.dispatch("resolve_decision",
|
||||
{"decision_id": did, "outcome": "worked out", "rating": "1"})
|
||||
assert f"#{did}" in out
|
||||
assert mem.get_decision(did).outcome_rating == 1
|
||||
|
||||
|
||||
def test_recall_decisions_tool_surfaces_outcomes(mem):
|
||||
from lyra import tools
|
||||
did = mem.log_decision(situation="Cleveland tournament again?", choice="play")
|
||||
mem.resolve_decision(did, "min-cashed", outcome_rating=0)
|
||||
out = tools.dispatch("recall_decisions", {"query": "poker tournament tomorrow"})
|
||||
assert "Cleveland" in out and "mixed" in out
|
||||
+1
-29
@@ -20,7 +20,7 @@ def lyra(tmp_path, monkeypatch):
|
||||
# reflect() expects JSON back; everything else just stores the text.
|
||||
monkeypatch.setattr(
|
||||
llm, "complete",
|
||||
lambda messages, backend=None, model=None, **_:
|
||||
lambda messages, backend=None, model=None:
|
||||
'{"mood":"focused","valence":0.7,"new_reflections":["I got some thinking done."]}',
|
||||
)
|
||||
|
||||
@@ -77,31 +77,3 @@ def test_dream_cycle_consolidates_and_persists(lyra):
|
||||
state2 = dream.dream_cycle(force=False)
|
||||
assert state2["dream"]["cycle_count"] == 2
|
||||
assert state2["drives"]["continuity"] == 0.0
|
||||
|
||||
|
||||
def test_dream_cycle_stops_when_over_budget(lyra, monkeypatch):
|
||||
memory = lyra
|
||||
from lyra import dream, notify
|
||||
|
||||
for k in range(7):
|
||||
_seed(memory, f"s{k}", 4)
|
||||
|
||||
# Go over budget right after the first heavy stage: first check passes
|
||||
# (summarize runs), every check after trips.
|
||||
checks = {"n": 0}
|
||||
|
||||
def fake_over(deadline):
|
||||
checks["n"] += 1
|
||||
return checks["n"] > 1
|
||||
monkeypatch.setattr(dream, "_over_budget", fake_over)
|
||||
|
||||
pings: list = []
|
||||
monkeypatch.setattr(notify, "push",
|
||||
lambda title, message, **k: pings.append((title, message)) or True)
|
||||
|
||||
state = dream.dream_cycle(force=True)
|
||||
acts = state["dream"]["last_actions"]
|
||||
|
||||
assert any("stopped early" in a for a in acts) # bailed
|
||||
assert not any("reflected" in a for a in acts) # later stage skipped
|
||||
assert pings, "expected an over-budget ntfy push"
|
||||
|
||||
@@ -1,126 +0,0 @@
|
||||
"""The canonical structured-hand contract (docs/HAND_HISTORY.md): normalize + export.
|
||||
|
||||
normalize_structured() is the single guarantee that every stored / replayed / exported
|
||||
hand has the versioned shape RTO consumes.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def poker(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", lambda texts: [[0.1, 0.2, 0.3] for _ in texts])
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
return poker
|
||||
|
||||
|
||||
def _full_hand():
|
||||
return {
|
||||
"game": "NLH", "stakes": "1/3", "hero_pos": "BTN",
|
||||
"hero_cards": ["ah", "kh"],
|
||||
"players": [
|
||||
{"pos": "BTN", "stack": 300, "name": "Hero"},
|
||||
{"pos": "BB", "stack": 250, "name": "Sal", "cards": ["qs", "qd"]},
|
||||
],
|
||||
"actions": [
|
||||
{"street": "preflop", "pos": "BTN", "action": "raise", "amount": 15},
|
||||
{"street": "flop", "board": ["7♦", "2♣", "5♥"]},
|
||||
{"street": "flop", "pos": "BB", "action": "check"},
|
||||
],
|
||||
"board": ["7♦", "2♣", "5♥"],
|
||||
"result": {"pot": 40, "hero_net": 25, "summary": "won at showdown"},
|
||||
}
|
||||
|
||||
|
||||
def test_stamps_version(poker):
|
||||
out = poker.normalize_structured({"hero_pos": "CO"})
|
||||
assert out["schema_version"] == poker.HAND_SCHEMA_VERSION
|
||||
|
||||
|
||||
def test_observed_hand_never_attributed_to_hero(poker):
|
||||
# Brian narrated a hand between two other players — hero_involved=false.
|
||||
out = poker.normalize_structured({
|
||||
"hero_involved": False,
|
||||
"hero_pos": "CO", "hero_cards": ["Kx", "Kx"], # model slipped these in
|
||||
"players": [{"pos": "CO", "cards": ["Kx", "Kx"]}, {"pos": "BB", "cards": ["Ax", "Ax"]}],
|
||||
"result": {"pot": 600, "hero_net": 300},
|
||||
})
|
||||
assert out["hero_pos"] is None # not pinned to Brian
|
||||
assert out["hero_cards"] == []
|
||||
assert out["result"]["hero_net"] is None # a pot he wasn't in
|
||||
assert not any(pl.get("hero") for pl in out["players"]) # nobody flagged hero
|
||||
|
||||
|
||||
def test_hero_hand_still_attributed(poker):
|
||||
out = poker.normalize_structured({
|
||||
"hero_involved": True, "hero_pos": "BTN", "hero_cards": ["As", "Ks"],
|
||||
"players": [{"pos": "BTN"}]})
|
||||
assert out["hero_pos"] == "BTN"
|
||||
hero = next(pl for pl in out["players"] if pl.get("pos") == "BTN")
|
||||
assert hero.get("hero") and hero["cards"] == ["As", "Ks"]
|
||||
|
||||
|
||||
def test_card_normalization(poker):
|
||||
out = poker.normalize_structured(_full_hand())
|
||||
assert out["hero_cards"] == ["Ah", "Kh"] # lowercased input -> canonical
|
||||
assert out["board"] == ["7d", "2c", "5h"] # unicode suits -> letters
|
||||
assert out["actions"][1]["board"] == ["7d", "2c", "5h"]
|
||||
# ten + suit symbol together
|
||||
assert poker.normalize_structured({"board": ["10♠"]})["board"] == ["Ts"]
|
||||
|
||||
|
||||
def test_unknown_cards_preserved(poker):
|
||||
out = poker.normalize_structured({"hero_cards": ["Ax", "x"], "board": ["Ax", "4x", "x"]})
|
||||
assert out["hero_cards"] == ["Ax", "x"] # placeholders kept, not dropped
|
||||
assert out["completeness"]["cards"] is False
|
||||
assert out["completeness"]["board"] is False
|
||||
|
||||
|
||||
def test_hero_synced_into_players(poker):
|
||||
out = poker.normalize_structured(_full_hand())
|
||||
hero = next(p for p in out["players"] if p["pos"] == "BTN")
|
||||
assert hero["hero"] is True
|
||||
assert hero["cards"] == ["Ah", "Kh"] # mirrored from hero_cards
|
||||
assert sum(1 for p in out["players"] if p.get("hero")) == 1
|
||||
|
||||
|
||||
def test_hero_inserted_when_missing_from_players(poker):
|
||||
out = poker.normalize_structured({"hero_pos": "SB", "hero_cards": ["As", "Ad"], "players": []})
|
||||
assert out["players"] == [{"pos": "SB", "hero": True, "cards": ["As", "Ad"]}]
|
||||
|
||||
|
||||
def test_completeness_full_hand(poker):
|
||||
c = poker.normalize_structured(_full_hand())["completeness"]
|
||||
assert c == {"cards": True, "board": True, "actions": True}
|
||||
|
||||
|
||||
def test_idempotent(poker):
|
||||
once = poker.normalize_structured(_full_hand())
|
||||
twice = poker.normalize_structured(once)
|
||||
assert once == twice
|
||||
|
||||
|
||||
def test_store_and_get_roundtrip_is_normalized(poker):
|
||||
sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
|
||||
hid = poker.store_hand_history(_full_hand(), session_id=sid, tag="well_played")
|
||||
got = poker.get_hand(hid)["structured"]
|
||||
assert got["schema_version"] == poker.HAND_SCHEMA_VERSION
|
||||
assert got["board"] == ["7d", "2c", "5h"]
|
||||
assert got["completeness"]["cards"] is True
|
||||
|
||||
|
||||
def test_list_recent_hands_flags_structured(poker):
|
||||
sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
|
||||
structured_id = poker.store_hand_history(_full_hand(), session_id=sid)
|
||||
flat_id = poker.log_hand(session_id=sid, position="CO", hole_cards="Jc Jd")
|
||||
rows = {r["id"]: r for r in poker.list_recent_hands()}
|
||||
assert rows[structured_id]["has_structured"] is True
|
||||
assert rows[flat_id]["has_structured"] is False
|
||||
@@ -1,66 +0,0 @@
|
||||
"""llm.complete: `max_tokens` and `timeout` are threaded into the backend call.
|
||||
|
||||
The OpenAI client is faked so nothing hits a network. We assert the generation
|
||||
cap reaches the create() call and the fast-fail timeout reaches the client (with
|
||||
max_retries=0 so summary.py owns the retry policy, not the SDK).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import types
|
||||
|
||||
import pytest
|
||||
|
||||
from lyra import llm
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_openai(monkeypatch):
|
||||
recorded: dict = {}
|
||||
|
||||
class FakeCompletions:
|
||||
def create(self, **kwargs):
|
||||
recorded["create"] = kwargs
|
||||
msg = types.SimpleNamespace(content="ok")
|
||||
return types.SimpleNamespace(choices=[types.SimpleNamespace(message=msg)])
|
||||
|
||||
class FakeClient:
|
||||
def __init__(self, **kwargs):
|
||||
recorded["client"] = kwargs
|
||||
self.chat = types.SimpleNamespace(completions=FakeCompletions())
|
||||
|
||||
monkeypatch.setattr(llm, "OpenAI", FakeClient)
|
||||
monkeypatch.setattr(llm, "load", lambda: types.SimpleNamespace(
|
||||
mi50_base_url="http://mi50/v1", mi50_model="local-gpu",
|
||||
cloud_model="gpt-4o-mini", openai_api_key="sk-test", local_model="l",
|
||||
))
|
||||
return recorded
|
||||
|
||||
|
||||
def test_mi50_threads_max_tokens_and_timeout(fake_openai):
|
||||
out = llm.complete([{"role": "user", "content": "hi"}],
|
||||
backend="mi50", max_tokens=768, timeout=150)
|
||||
|
||||
assert out == "ok"
|
||||
assert fake_openai["create"]["max_tokens"] == 768
|
||||
assert fake_openai["client"]["timeout"] == 150
|
||||
assert fake_openai["client"]["max_retries"] == 0
|
||||
|
||||
|
||||
def test_cloud_threads_max_tokens_and_timeout(fake_openai):
|
||||
llm.complete([{"role": "user", "content": "hi"}],
|
||||
backend="cloud", max_tokens=768, timeout=150)
|
||||
|
||||
assert fake_openai["create"]["max_tokens"] == 768
|
||||
assert fake_openai["client"]["timeout"] == 150
|
||||
assert fake_openai["client"]["max_retries"] == 0
|
||||
|
||||
|
||||
def test_default_bounds_calls_even_without_explicit_timeout(fake_openai):
|
||||
# No cap / timeout passed -> still bounded: 300s default + no SDK retries, so
|
||||
# no call can silently inherit the SDK's 600s x2 (~30 min). No length cap
|
||||
# unless asked, though.
|
||||
llm.complete([{"role": "user", "content": "hi"}], backend="mi50")
|
||||
|
||||
assert "max_tokens" not in fake_openai["create"]
|
||||
assert fake_openai["client"]["timeout"] == 300
|
||||
assert fake_openai["client"]["max_retries"] == 0
|
||||
@@ -1,70 +0,0 @@
|
||||
"""Pattern desk: embedded scar recall + strategy gating in the scouting desk."""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import importlib
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
|
||||
def _idx(w: str) -> int:
|
||||
# Stable across processes (unlike hash()), so threshold tests aren't flaky.
|
||||
return int.from_bytes(hashlib.md5(w.encode()).digest()[:4], "little") % 256
|
||||
|
||||
|
||||
def _fake_embed(texts):
|
||||
out = []
|
||||
for t in texts:
|
||||
v = np.zeros(256, dtype=np.float32)
|
||||
for w in t.lower().split():
|
||||
v[_idx(w)] += 1.0
|
||||
out.append((v if v.any() else np.full(256, 1e-6, dtype=np.float32)).tolist())
|
||||
return out
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mods(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", _fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
import lyra.scouting as scouting
|
||||
importlib.reload(scouting)
|
||||
return poker, scouting
|
||||
|
||||
|
||||
def test_scar_recall_finds_similar_past_leak(mods):
|
||||
poker, _ = mods
|
||||
old = poker.start_session(stakes="1/3", buy_in=300)
|
||||
poker.log_ritual("scar", "overvalued top pair and stacked off on a wet board",
|
||||
classification="punt", session_id=old)
|
||||
poker.end_session(200, session_id=old)
|
||||
hits = poker.recall_similar_rituals("stacked off top pair wet board again")
|
||||
assert hits and hits[0]["classification"] == "punt"
|
||||
|
||||
|
||||
def test_recall_excludes_current_session(mods):
|
||||
poker, _ = mods
|
||||
sid = poker.start_session(stakes="1/3", buy_in=300)
|
||||
poker.log_ritual("scar", "punted river bluff into the nut flush", session_id=sid)
|
||||
assert poker.recall_similar_rituals("river bluff nut flush punt", exclude_session=sid) == []
|
||||
|
||||
|
||||
def test_pattern_pass_only_fires_on_strategic_talk(mods):
|
||||
poker, scouting = mods
|
||||
old = poker.start_session(stakes="1/3", buy_in=300)
|
||||
poker.log_ritual("scar", "punting river bluffs into missed draws again",
|
||||
classification="punt", session_id=old)
|
||||
poker.end_session(200, session_id=old)
|
||||
poker.start_session(stakes="1/3", buy_in=300, venue="Meadows")
|
||||
# A routine, non-strategic line pays no embed and surfaces nothing.
|
||||
assert scouting.scout("stack is 350 now", venue="Meadows") is None
|
||||
# A real strategy question in the same shape recalls the leak. (The test stub
|
||||
# embeds by shared tokens; real embeddings match on meaning/paraphrase.)
|
||||
note = scouting.scout(
|
||||
"why do i keep punting river bluffs into missed draws", venue="Meadows")
|
||||
assert note and "punting river bluffs" in note
|
||||
@@ -18,50 +18,6 @@ def lyra(tmp_path, monkeypatch):
|
||||
return poker
|
||||
|
||||
|
||||
def test_disown_hand_clears_hero_attribution(lyra):
|
||||
poker = lyra
|
||||
sid = poker.start_session(venue="Meadows", buy_in=300)
|
||||
hid = poker.store_hand_history(
|
||||
{"hero_involved": True, "hero_pos": "MP", "hero_cards": ["As", "3d"],
|
||||
"players": [{"pos": "MP", "cards": ["As", "3d"]}],
|
||||
"result": {"pot": 600, "hero_net": 304}}, session_id=sid, tag="notable")
|
||||
h = poker.disown_hand(hid)
|
||||
assert h["position"] is None and h["hole_cards"] is None and h["result"] is None
|
||||
st = h["structured"]
|
||||
if isinstance(st, str):
|
||||
import json
|
||||
st = json.loads(st)
|
||||
assert st["hero_pos"] is None and not any(pl.get("hero") for pl in st["players"])
|
||||
|
||||
|
||||
def test_hud_notes_scoped_to_session_by_tag(lyra):
|
||||
poker = lyra
|
||||
from lyra import memory
|
||||
sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=300)
|
||||
# A note tagged to THIS session shows on its HUD...
|
||||
memory.add_journal_entry("note", "villain 3 overfolds turn", source=f"poker:{sid}")
|
||||
# ...her autonomous existential journaling (any other source) does NOT, even
|
||||
# though it's written during the exact same window...
|
||||
memory.add_journal_entry("journal", "the quiet dread between conversations", source="dream")
|
||||
# ...nor a note from a *different* poker session.
|
||||
memory.add_journal_entry("note", "some other night", source=f"poker:{sid + 999}")
|
||||
contents = [n["content"] for n in poker.hud(sid)["notes"]]
|
||||
assert contents == ["villain 3 overfolds turn"]
|
||||
|
||||
|
||||
def test_note_tool_tags_live_poker_session(lyra):
|
||||
poker = lyra
|
||||
from lyra import tools
|
||||
sid = poker.start_session(stakes="1/3", buy_in=300)
|
||||
tools.dispatch("note", {"content": "whale just sat down seat 4"}, {})
|
||||
assert poker.hud(sid)["notes"][0]["content"] == "whale just sat down seat 4"
|
||||
poker.end_session(cash_out=300, session_id=sid)
|
||||
# With no live session, a note falls back to the general journal (source=chat),
|
||||
# so it does NOT attach to the just-closed session's HUD.
|
||||
tools.dispatch("note", {"content": "random afternoon idea"}, {})
|
||||
assert all(n["content"] != "random afternoon idea" for n in poker.hud(sid)["notes"])
|
||||
|
||||
|
||||
def test_session_lifecycle_and_net(lyra):
|
||||
poker = lyra
|
||||
sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
|
||||
|
||||
@@ -1,82 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(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.web.server as server
|
||||
importlib.reload(server)
|
||||
from fastapi.testclient import TestClient
|
||||
return TestClient(server.app), poker
|
||||
|
||||
|
||||
def test_post_stack_logs_and_returns_state(client):
|
||||
c, poker = client
|
||||
poker.start_session(venue="Meadows", stakes="1/3", buy_in=400)
|
||||
r = c.post("/session/stack", json={"amount": 373})
|
||||
assert r.status_code == 200
|
||||
body = r.json()
|
||||
assert body["ok"] is True
|
||||
assert body["stack"]["current"] == 373
|
||||
assert body["stack"]["net"] == pytest.approx(-27)
|
||||
|
||||
|
||||
def test_post_stack_without_session_errors(client):
|
||||
c, _ = client
|
||||
r = c.post("/session/stack", json={"amount": 373})
|
||||
assert r.json()["ok"] is False
|
||||
assert "error" in r.json()
|
||||
|
||||
|
||||
def test_post_buyin_increments_total(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/buyin", json={"amount": 200})
|
||||
assert r.json()["buy_in_total"] == pytest.approx(600)
|
||||
|
||||
|
||||
def test_post_session_starts_live(client):
|
||||
c, poker = client
|
||||
r = c.post("/session", json={"venue": "Wheeling", "stakes": "1/3", "buy_in": 400})
|
||||
sid = r.json()["id"]
|
||||
assert poker.live_session()["id"] == sid
|
||||
|
||||
|
||||
def test_post_hand_edit_and_delete(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/hand", json={"position": "BTN", "hole_cards": "22", "result": 120})
|
||||
assert r.json()["ok"] is True
|
||||
hid = r.json()["id"]
|
||||
r2 = c.patch(f"/hand/{hid}", json={"hole_cards": "2c2d"})
|
||||
assert r2.json()["ok"] is True
|
||||
assert r2.json()["hand"]["hole_cards"] == "2c2d"
|
||||
r3 = c.delete(f"/hand/{hid}")
|
||||
assert r3.json()["ok"] is True
|
||||
assert poker.get_hand(hid) is None
|
||||
|
||||
|
||||
def test_post_read(client):
|
||||
c, poker = client
|
||||
poker.start_session(buy_in=400)
|
||||
r = c.post("/session/read", json={"note": "3-bets light", "name": "James K"})
|
||||
assert r.json()["ok"] is True
|
||||
assert isinstance(r.json()["id"], int)
|
||||
|
||||
|
||||
def test_rename_player_fixes_mislabel(client):
|
||||
c, poker = client
|
||||
pid = poker.upsert_player("Dave the rock", category="reg")
|
||||
r = c.patch(f"/player/{pid}", json={"name": "Dave the mechanic"})
|
||||
assert r.json()["ok"] is True
|
||||
assert r.json()["player"]["name"] == "Dave the mechanic"
|
||||
@@ -1,33 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from lyra import tools
|
||||
from lyra.poker_contract import OPERATIONS
|
||||
|
||||
|
||||
def test_llm_tool_required_args_match_contract():
|
||||
for op, decl in OPERATIONS.items():
|
||||
name = decl["llm_tool"]
|
||||
if not name:
|
||||
continue
|
||||
spec = tools.TOOLS[name]["spec"]
|
||||
required = set(spec["function"]["parameters"]["required"])
|
||||
assert required == set(decl["required"]), (
|
||||
f"{op}: tools spec required {required} != contract {set(decl['required'])}"
|
||||
)
|
||||
|
||||
|
||||
def test_rest_routes_registered():
|
||||
import lyra.web.server as server
|
||||
registered = set()
|
||||
for route in server.app.routes:
|
||||
methods = getattr(route, "methods", None)
|
||||
path = getattr(route, "path", None)
|
||||
if not methods or not path:
|
||||
continue
|
||||
for m in methods:
|
||||
registered.add((m, path))
|
||||
for op, decl in OPERATIONS.items():
|
||||
if not decl["rest"]:
|
||||
continue
|
||||
method, path = decl["rest"]
|
||||
assert (method, path) in registered, f"{op}: {method} {path} not registered"
|
||||
@@ -1,101 +0,0 @@
|
||||
"""Live table roster: seat players, attach reads by handle, roster on the HUD."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
|
||||
def _fake_embed(texts):
|
||||
out = []
|
||||
for t in texts:
|
||||
v = np.zeros(64, dtype=np.float32)
|
||||
for w in t.lower().split():
|
||||
v[hash(w) % 64] += 1.0
|
||||
out.append((v if v.any() else np.full(64, 1e-6, dtype=np.float32)).tolist())
|
||||
return out
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mods(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", _fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
import lyra.tools as tools
|
||||
importlib.reload(tools)
|
||||
return poker, tools
|
||||
|
||||
|
||||
def test_seat_players_builds_roster(mods):
|
||||
poker, _ = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
n = poker.seat_players(["TAG", "Jonathan", {"name": "Wheelz", "seat": "3"}])
|
||||
assert n == 3
|
||||
roster = poker.session_roster()
|
||||
names = {r["name"] for r in roster}
|
||||
assert names == {"TAG", "Jonathan", "Wheelz"}
|
||||
assert next(r for r in roster if r["name"] == "Wheelz")["seat"] == "3"
|
||||
|
||||
|
||||
def test_read_attaches_to_seated_player_by_handle(mods):
|
||||
poker, _ = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.seat_players(["TAG"])
|
||||
poker.add_read(note="limped A4o from the SB, UTG straddle", name="TAG")
|
||||
roster = poker.session_roster()
|
||||
tag = next(r for r in roster if r["name"] == "TAG")
|
||||
assert tag["reads"] == 1 and "A4o" in tag["last_note"]
|
||||
# No duplicate TAG spawned — the read landed on the seated player.
|
||||
assert sum(p["name"] == "TAG" for p in poker.get_villain_file()) == 1
|
||||
|
||||
|
||||
def test_seat_players_tool_and_roster_in_hud(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
out = tools.dispatch("seat_players", {"players": [{"name": "TAG"}, {"name": "JD"}]}, {})
|
||||
assert "TAG" in out and "JD" in out
|
||||
assert len(poker.hud()["roster"]) == 2
|
||||
|
||||
|
||||
def test_unseat_player_removes_from_roster_keeps_history(mods):
|
||||
poker, _ = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.seat_players(["TAG"])
|
||||
poker.add_read(note="showed a bluff", name="TAG")
|
||||
assert poker.unseat_player(name="TAG") is True
|
||||
assert poker.session_roster() == [] # off the table
|
||||
assert poker.player_profile("TAG")["reads"] # history intact
|
||||
|
||||
|
||||
def test_clear_table_empties_roster_keeps_reads(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.seat_players(["TAG", "Jonathan"])
|
||||
poker.add_read(note="limped A4o", name="TAG")
|
||||
out = tools.dispatch("clear_table", {}, {})
|
||||
assert "cleared" in out.lower()
|
||||
assert poker.session_roster() == [] # roster emptied
|
||||
assert poker.player_profile("TAG")["reads"] # reads kept
|
||||
# A live session is untouched by clearing the table.
|
||||
assert poker.live_session() is not None
|
||||
|
||||
|
||||
def test_seat_players_replace_swaps_to_new_table(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.seat_players(["TAG", "Jonathan"])
|
||||
tools.dispatch("seat_players", {"players": [{"name": "Doyle"}, {"name": "Ivey"}],
|
||||
"replace": True}, {})
|
||||
assert {r["name"] for r in poker.session_roster()} == {"Doyle", "Ivey"}
|
||||
|
||||
|
||||
def test_seat_players_accepts_plain_name_list_via_tool(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
tools.dispatch("seat_players", {"players": "TAG, JD, Wheelz"}, {})
|
||||
assert {r["name"] for r in poker.session_roster()} == {"TAG", "JD", "Wheelz"}
|
||||
@@ -1,73 +0,0 @@
|
||||
"""The scouting desk: named + descriptor recall, ambiguous→queue, generic→silence."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
|
||||
def _fake_embed(texts):
|
||||
out = []
|
||||
for t in texts:
|
||||
v = np.zeros(64, dtype=np.float32)
|
||||
for w in t.lower().split():
|
||||
v[hash(w) % 64] += 1.0
|
||||
out.append((v if v.any() else np.full(64, 1e-6, dtype=np.float32)).tolist())
|
||||
return out
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mods(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", _fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
import lyra.scouting as scouting
|
||||
importlib.reload(scouting)
|
||||
return poker, scouting
|
||||
|
||||
|
||||
def test_named_player_surfaces_a_brief(mods):
|
||||
poker, scouting = mods
|
||||
sid = poker.start_session(venue="Meadows", stakes="1/3", buy_in=300)
|
||||
pid = poker.upsert_player("Sleepy John", venue="Meadows", category="reg")
|
||||
poker._c().execute(
|
||||
"INSERT INTO player_observations (player_id, session_id, cards, created_at) VALUES (?,?,?,?)",
|
||||
(pid, sid, "As Ks", poker._now()))
|
||||
poker._c().commit()
|
||||
note = scouting.scout("sleepy john just sat down on my left", venue="Meadows")
|
||||
assert note and "Sleepy John" in note and "SCOUTING DESK" in note
|
||||
|
||||
|
||||
def test_descriptor_high_match_surfaces_with_confirm(mods):
|
||||
poker, scouting = mods
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows", category="reg")
|
||||
note = scouting.scout("the neck tattoo sleeve guy just 3bet me again", venue="Meadows")
|
||||
assert note and "confirm it's the same guy" in note
|
||||
|
||||
|
||||
def test_ambiguous_descriptor_queues_instead_of_interrupting(mods):
|
||||
poker, scouting = mods
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
note = scouting.scout("the neck tattoo guy raised", venue="Meadows")
|
||||
assert note is None # didn't interrupt
|
||||
q = poker.list_identity_queue()
|
||||
assert q and q[0]["kind"] == "needs_clarification"
|
||||
|
||||
|
||||
def test_generic_descriptor_stays_silent(mods):
|
||||
poker, scouting = mods
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
note = scouting.scout("the mid aged white guy with glasses raised", venue="Meadows")
|
||||
assert note is None
|
||||
assert poker.list_identity_queue() == [] # no queue spam for a non-identifier
|
||||
|
||||
|
||||
def test_no_player_reference_returns_nothing(mods):
|
||||
poker, scouting = mods
|
||||
poker.upsert_player("Sleepy John", venue="Meadows")
|
||||
assert scouting.scout("i folded pocket kings to a 4bet", venue="Meadows") is None
|
||||
@@ -1,142 +0,0 @@
|
||||
"""Summary consolidation: MI50 length cap, fast-fail, and cloud fallback.
|
||||
|
||||
Everything is stubbed — no real backend is touched. These drive the behavior of
|
||||
`summary._summarize_text`: try the primary backend a bounded number of times with
|
||||
a capped generation length, and fall back to cloud if the primary keeps failing.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import types
|
||||
|
||||
import pytest
|
||||
|
||||
from lyra import summary
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def calls(monkeypatch):
|
||||
"""Capture every llm.complete call; per-test behavior via `fake.responder`."""
|
||||
recorded: list[dict] = []
|
||||
|
||||
def fake_complete(messages, backend="local", model=None,
|
||||
max_tokens=None, timeout=None):
|
||||
recorded.append({"backend": backend, "max_tokens": max_tokens, "timeout": timeout})
|
||||
return fake_complete.responder(backend)
|
||||
|
||||
fake_complete.responder = lambda backend: "gist"
|
||||
monkeypatch.setattr(summary.llm, "complete", fake_complete)
|
||||
monkeypatch.setattr(summary.time, "sleep", lambda *_: None) # instant backoff
|
||||
return types.SimpleNamespace(recorded=recorded, fake=fake_complete)
|
||||
|
||||
|
||||
def _set_key(monkeypatch, key="sk-test"):
|
||||
monkeypatch.setattr(summary.config, "load",
|
||||
lambda: types.SimpleNamespace(openai_api_key=key))
|
||||
|
||||
|
||||
def test_falls_back_to_cloud_after_mi50_attempts(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
|
||||
def responder(backend):
|
||||
if backend == "mi50":
|
||||
raise RuntimeError("Request timed out.")
|
||||
return "cloud-gist"
|
||||
calls.fake.responder = responder
|
||||
|
||||
out = summary._summarize_text("transcript", "mi50")
|
||||
|
||||
assert out == "cloud-gist"
|
||||
assert [c["backend"] for c in calls.recorded] == ["mi50", "mi50", "cloud"]
|
||||
|
||||
|
||||
def test_no_fallback_when_backend_is_cloud(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
calls.fake.responder = lambda backend: (_ for _ in ()).throw(RuntimeError("boom"))
|
||||
|
||||
with pytest.raises(RuntimeError):
|
||||
summary._summarize_text("t", "cloud")
|
||||
|
||||
# Cloud is already the primary: retry it, but never a redundant fallback.
|
||||
assert [c["backend"] for c in calls.recorded] == ["cloud", "cloud"]
|
||||
|
||||
|
||||
def test_no_fallback_without_openai_key(calls, monkeypatch):
|
||||
_set_key(monkeypatch, key="")
|
||||
calls.fake.responder = lambda backend: (_ for _ in ()).throw(RuntimeError("mi50 down"))
|
||||
|
||||
with pytest.raises(RuntimeError):
|
||||
summary._summarize_text("t", "mi50")
|
||||
|
||||
assert [c["backend"] for c in calls.recorded] == ["mi50", "mi50"]
|
||||
|
||||
|
||||
def test_caps_length_and_timeout_on_every_call(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
|
||||
def responder(backend):
|
||||
if backend == "mi50":
|
||||
raise RuntimeError("nope")
|
||||
return "cloud-gist"
|
||||
calls.fake.responder = responder
|
||||
|
||||
summary._summarize_text("t", "mi50")
|
||||
|
||||
assert calls.recorded
|
||||
for c in calls.recorded:
|
||||
assert c["max_tokens"] == summary.SUMMARY_MAX_TOKENS
|
||||
assert c["timeout"] == summary.SUMMARY_TIMEOUT
|
||||
|
||||
|
||||
def test_happy_path_uses_primary_only(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
calls.fake.responder = lambda backend: "mi50-gist"
|
||||
|
||||
out = summary._summarize_text("t", "mi50")
|
||||
|
||||
assert out == "mi50-gist"
|
||||
assert [c["backend"] for c in calls.recorded] == ["mi50"] # no retries, no fallback
|
||||
|
||||
|
||||
# --- degenerate ("?" garbage) output guard: a wedged local model returns junk as
|
||||
# a successful 200, so treat it as a failure and fall back to cloud. ---
|
||||
|
||||
def test_looks_degenerate_flags_repeated_char():
|
||||
assert summary._looks_degenerate("?" * 60) is True
|
||||
assert summary._looks_degenerate("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") is True
|
||||
|
||||
|
||||
def test_looks_degenerate_passes_real_prose():
|
||||
gist = ("Brian sat down at the Meadows 1/3 in seat 6 with two straddles active; "
|
||||
"he tagged a seat-3 calling station and finished the session up 240.")
|
||||
assert summary._looks_degenerate(gist) is False
|
||||
|
||||
|
||||
def test_looks_degenerate_ignores_short_output():
|
||||
# Too short to judge — don't false-positive a terse-but-valid reply.
|
||||
assert summary._looks_degenerate("ok") is False
|
||||
|
||||
|
||||
def test_degenerate_mi50_output_falls_back_to_cloud(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
|
||||
def responder(backend):
|
||||
if backend == "mi50":
|
||||
return "?" * 200 # garbage-as-200, not an exception
|
||||
return "a real cloud gist of the session, diverse and coherent."
|
||||
calls.fake.responder = responder
|
||||
|
||||
out = summary._summarize_text("transcript", "mi50")
|
||||
|
||||
assert "cloud gist" in out
|
||||
assert [c["backend"] for c in calls.recorded] == ["mi50", "mi50", "cloud"]
|
||||
|
||||
|
||||
def test_degenerate_cloud_output_raises_no_infinite_loop(calls, monkeypatch):
|
||||
_set_key(monkeypatch)
|
||||
calls.fake.responder = lambda backend: "?" * 200 # every backend returns garbage
|
||||
|
||||
with pytest.raises(Exception):
|
||||
summary._summarize_text("t", "mi50")
|
||||
|
||||
# mi50 x2, then one cloud fallback that's also garbage -> give up, no loop.
|
||||
assert [c["backend"] for c in calls.recorded] == ["mi50", "mi50", "cloud"]
|
||||
@@ -1,82 +0,0 @@
|
||||
"""Conversation export: speech (exchanges) + actions (tool_events) merged in order."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
def _const_embed(texts):
|
||||
return [[1e-6] * 8 for _ in texts]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mods(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", _const_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.transcript as transcript
|
||||
importlib.reload(transcript)
|
||||
return memory, transcript
|
||||
|
||||
|
||||
def _seed(memory):
|
||||
"""A turn where Brian narrates a hand and Lyra logs it, then replies."""
|
||||
memory.ensure_session("s1", name="Meadows 1/3")
|
||||
memory.remember("s1", "user", "got it in with a set, he had the flush draw and bricked")
|
||||
memory.add_tool_event("s1", "record_hand", {"result": "won", "pot": 750}, "hand #42 logged")
|
||||
memory.add_tool_event("s1", "log_stack", {"amount": 750, "note": "doubled up"}, "ok")
|
||||
memory.remember("s1", "assistant", "Clean stack-off — logged it to your timeline.")
|
||||
|
||||
|
||||
def test_tool_events_roundtrip_parses_args(mods):
|
||||
memory, _ = mods
|
||||
_seed(memory)
|
||||
events = memory.tool_events("s1")
|
||||
assert [e["tool"] for e in events] == ["record_hand", "log_stack"]
|
||||
assert events[0]["args"] == {"result": "won", "pot": 750} # parsed back to a dict
|
||||
assert events[1]["result"] == "ok"
|
||||
|
||||
|
||||
def test_markdown_interleaves_speech_and_actions_in_order(mods):
|
||||
memory, transcript = mods
|
||||
_seed(memory)
|
||||
md = transcript.as_markdown("s1", name="Meadows 1/3")
|
||||
# user message, then both tool calls, then assistant reply — in that order
|
||||
i_user = md.index("got it in with a set")
|
||||
i_hand = md.index("record_hand")
|
||||
i_stack = md.index("log_stack")
|
||||
i_reply = md.index("Clean stack-off")
|
||||
assert i_user < i_hand < i_stack < i_reply
|
||||
assert "**Brian**" in md and "**Lyra**" in md
|
||||
assert "⚙" in md
|
||||
|
||||
|
||||
def test_json_export_is_machine_readable(mods):
|
||||
memory, transcript = mods
|
||||
_seed(memory)
|
||||
payload = transcript.as_json("s1", name="Meadows 1/3")
|
||||
assert payload["session_id"] == "s1"
|
||||
types = [e["type"] for e in payload["events"]]
|
||||
assert types == ["message", "tool", "tool", "message"]
|
||||
json.dumps(payload) # must be serializable
|
||||
|
||||
|
||||
def test_build_returns_filename_and_media_type(mods):
|
||||
memory, transcript = mods
|
||||
_seed(memory)
|
||||
body_md, mt_md, fn_md = transcript.build("s1", "md", "Meadows 1/3")
|
||||
body_js, mt_js, fn_js = transcript.build("s1", "json", "Meadows 1/3")
|
||||
assert fn_md.endswith(".md") and "markdown" in mt_md
|
||||
assert fn_js.endswith(".json") and mt_js == "application/json"
|
||||
assert body_md and body_js
|
||||
|
||||
|
||||
def test_delete_session_clears_tool_events(mods):
|
||||
memory, _ = mods
|
||||
_seed(memory)
|
||||
memory.delete_session("s1")
|
||||
assert memory.tool_events("s1") == []
|
||||
@@ -1,103 +0,0 @@
|
||||
"""Confirm-loop tools: descriptor reads, name attach, merge/mark-distinct."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
|
||||
def _fake_embed(texts):
|
||||
out = []
|
||||
for t in texts:
|
||||
v = np.zeros(64, dtype=np.float32)
|
||||
for w in t.lower().split():
|
||||
v[hash(w) % 64] += 1.0
|
||||
out.append((v if v.any() else np.full(64, 1e-6, dtype=np.float32)).tolist())
|
||||
return out
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mods(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("LYRA_DB_PATH", str(tmp_path / "test.db"))
|
||||
from lyra import llm
|
||||
monkeypatch.setattr(llm, "embed", _fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
import lyra.tools as tools
|
||||
importlib.reload(tools)
|
||||
return poker, tools
|
||||
|
||||
|
||||
def test_descriptor_read_creates_then_reuses_nameless_villain(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", stakes="1/3", buy_in=300)
|
||||
tools.dispatch("add_read", {"note": "opened UTG light",
|
||||
"descriptor": "neck tattoo sleeve arm"}, {})
|
||||
tools.dispatch("add_read", {"note": "showed a bluff",
|
||||
"descriptor": "neck tattoo sleeve"}, {}) # rephrase → same guy
|
||||
players = [p for p in poker.get_villain_file() if not p["named"]]
|
||||
assert len(players) == 1 # one nameless villain, not two
|
||||
reads = poker._c().execute(
|
||||
"SELECT COUNT(*) n FROM player_reads WHERE player_id = ?", (players[0]["id"],)
|
||||
).fetchone()["n"]
|
||||
assert reads == 2
|
||||
|
||||
|
||||
def test_description_as_name_routes_to_descriptor_and_dedupes(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
# She (wrongly) puts a physical description in the name field, twice, worded
|
||||
# slightly differently — must resolve to ONE nameless villain, not two named.
|
||||
tools.dispatch("add_read", {"note": "limp 3bet A3o",
|
||||
"name": "Filipino, Fox Racing hat, DKNY shirt, two bracelets"}, {})
|
||||
tools.dispatch("add_read", {"note": "called a 4bet light",
|
||||
"name": "Filipino, Fox Racing hat, DKNY shirt, watch on left"}, {})
|
||||
named = [p for p in poker.get_villain_file() if p["named"]]
|
||||
assert named == [] # no sentence-named players spawned (the bug)
|
||||
# Either they merged, or the near-dup is surfaced for a one-click merge — never
|
||||
# a silent duplicate the way sentence-names were.
|
||||
q = poker.list_identity_queue()
|
||||
nameless = [p for p in poker.get_villain_file() if not p["named"]]
|
||||
assert len(nameless) == 1 or any(t["kind"] == "merge_candidate" for t in q)
|
||||
|
||||
|
||||
def test_name_villain_tool_attaches_name(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
out = tools.dispatch("name_villain", {"descriptor": "neck tattoo sleeve arm",
|
||||
"name": "Danny"}, {})
|
||||
assert "Danny" in out
|
||||
assert poker.resolve_villain("Danny")["band"] == "name"
|
||||
|
||||
|
||||
def test_link_villains_merge_and_distinct(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.upsert_player("Danny", venue="Meadows")
|
||||
poker.upsert_player("Donny", venue="Meadows")
|
||||
# same=false → recorded distinct
|
||||
tools.dispatch("link_villains", {"player_a": "Danny", "player_b": "Donny",
|
||||
"same": False, "note": "different builds"}, {})
|
||||
a = poker.resolve_villain("Danny")["match_id"]
|
||||
b = poker.resolve_villain("Donny")["match_id"]
|
||||
assert poker.are_distinct(a, b)
|
||||
# same=true on a fresh pair → merged
|
||||
poker.upsert_player("Mike", venue="Meadows")
|
||||
poker.upsert_player("Michael", venue="Meadows")
|
||||
tools.dispatch("link_villains", {"player_a": "Mike", "player_b": "Michael",
|
||||
"same": True}, {})
|
||||
names = [p["name"] for p in poker.get_villain_file()]
|
||||
assert ("Mike" in names) ^ ("Michael" in names) # one absorbed the other
|
||||
|
||||
|
||||
def test_link_villains_refuses_when_reference_is_vague(mods):
|
||||
poker, tools = mods
|
||||
poker.start_session(venue="Meadows", buy_in=300)
|
||||
poker.upsert_player("Danny", venue="Meadows")
|
||||
out = tools.dispatch("link_villains", {"player_a": "Danny",
|
||||
"player_b": "some guy", "same": True}, {})
|
||||
assert "didn't merge" in out.lower() or "couldn't" in out.lower()
|
||||
@@ -1,116 +0,0 @@
|
||||
"""Nameless-villain identity resolution: descriptor matching, merge, distinct, queue."""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
|
||||
def _fake_embed(texts):
|
||||
"""Overlap-sensitive bag-of-words vectors so cosine reflects shared tokens."""
|
||||
out = []
|
||||
for t in texts:
|
||||
v = np.zeros(64, dtype=np.float32)
|
||||
for w in t.lower().split():
|
||||
v[hash(w) % 64] += 1.0
|
||||
out.append((v if v.any() else np.full(64, 1e-6, dtype=np.float32)).tolist())
|
||||
return out
|
||||
|
||||
|
||||
@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", _fake_embed)
|
||||
import lyra.memory as memory
|
||||
importlib.reload(memory)
|
||||
import lyra.poker as poker
|
||||
importlib.reload(poker)
|
||||
return poker
|
||||
|
||||
|
||||
def test_distinctiveness_distinctive_vs_generic(poker):
|
||||
assert poker.distinctiveness("guy with a neck tattoo") > 0.6
|
||||
assert poker.distinctiveness("mid-aged white dude with glasses") < 0.3
|
||||
|
||||
|
||||
def test_generic_descriptor_never_resolves_to_a_guess(poker):
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
r = poker.resolve_villain("mid aged white guy with glasses", venue="Meadows")
|
||||
assert r["band"] == "generic"
|
||||
assert r["match_id"] is None
|
||||
|
||||
|
||||
def test_exact_name_match_is_deterministic(poker):
|
||||
pid = poker.upsert_player("Sleepy John", venue="Meadows")
|
||||
r = poker.resolve_villain("sleepy john")
|
||||
assert r["band"] == "name" and r["match_id"] == pid
|
||||
|
||||
|
||||
def test_rephrased_descriptor_resolves_high(poker):
|
||||
pid = poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
r = poker.resolve_villain("neck tattoo sleeve", venue="Meadows")
|
||||
assert r["band"] == "high" and r["match_id"] == pid
|
||||
assert r["confidence"] >= 0.80
|
||||
|
||||
|
||||
def test_partial_descriptor_is_ambiguous_not_high(poker):
|
||||
poker.create_descriptor_villain("neck tattoo sleeve arm", venue="Meadows")
|
||||
r = poker.resolve_villain("neck tattoo", venue="Meadows")
|
||||
assert r["band"] == "ambiguous" # plausible, but don't guess live
|
||||
|
||||
|
||||
def test_merge_repoints_observations_and_deletes_dup(poker):
|
||||
keep = poker.create_descriptor_villain("neck tattoo", venue="Meadows")
|
||||
dup = poker.create_descriptor_villain("neck ink tatted", venue="Meadows")
|
||||
poker._c().execute(
|
||||
"INSERT INTO player_observations (player_id, session_id, created_at) VALUES (?,1,?)",
|
||||
(dup, poker._now()))
|
||||
poker._c().commit()
|
||||
assert poker.merge_players(keep, dup) is True
|
||||
assert poker.get_villain_file() and all(p["id"] != dup for p in poker.get_villain_file())
|
||||
obs = poker._c().execute(
|
||||
"SELECT COUNT(*) n FROM player_observations WHERE player_id = ?", (keep,)).fetchone()["n"]
|
||||
assert obs == 1
|
||||
|
||||
|
||||
def test_merge_prefers_a_real_name(poker):
|
||||
named = poker.upsert_player("Danny", venue="Meadows")
|
||||
desc = poker.create_descriptor_villain("neck tattoo", venue="Meadows")
|
||||
poker.merge_players(desc, named) # keep the descriptor id, but name should win
|
||||
row = dict(poker._c().execute("SELECT name, named FROM poker_players WHERE id = ?", (desc,)).fetchone())
|
||||
assert row["name"] == "Danny" and row["named"] == 1
|
||||
|
||||
|
||||
def test_mark_distinct_blocks_merge_scan(poker):
|
||||
a = poker.create_descriptor_villain("neck tattoo sleeve", venue="Meadows")
|
||||
b = poker.create_descriptor_villain("neck tattoo sleeve", venue="Meadows")
|
||||
poker.mark_distinct(a, b, note="one's taller")
|
||||
assert poker.are_distinct(a, b)
|
||||
assert poker.scan_merge_candidates() == 0 # confirmed-distinct pair is skipped
|
||||
|
||||
|
||||
def test_scan_files_merge_candidate_for_near_duplicates(poker):
|
||||
poker.create_descriptor_villain("neck tattoo sleeve", venue="Meadows")
|
||||
poker.create_descriptor_villain("neck tattoo sleeve", venue="Meadows")
|
||||
filed = poker.scan_merge_candidates()
|
||||
assert filed == 1
|
||||
q = poker.list_identity_queue()
|
||||
assert q and q[0]["kind"] == "merge_candidate" and len(q[0]["players"]) == 2
|
||||
|
||||
|
||||
def test_queue_dedupes_identical_pending_task(poker):
|
||||
a = poker.create_descriptor_villain("neck tattoo", venue="Meadows")
|
||||
b = poker.create_descriptor_villain("neck ink", venue="Meadows")
|
||||
t1 = poker.queue_identity_task("merge_candidate", [a, b])
|
||||
t2 = poker.queue_identity_task("merge_candidate", [b, a]) # same pair, reversed
|
||||
assert t1 == t2
|
||||
assert len(poker.list_identity_queue()) == 1
|
||||
|
||||
|
||||
def test_name_villain_flips_named_flag(poker):
|
||||
pid = poker.create_descriptor_villain("neck tattoo", venue="Meadows")
|
||||
poker.name_villain(pid, "Danny")
|
||||
r = poker.resolve_villain("Danny")
|
||||
assert r["band"] == "name" and r["match_id"] == pid
|
||||
Reference in New Issue
Block a user