File size: 26,742 Bytes
2e10c7a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
be6f870
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e10c7a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
"""The console's Trades and Model & training pages (fly_trader/ui/api/{trades,model}.py): each chain's books are offered in
order before their first trade and every view reads them, the closed-trade / decision-log / fills topics return their
rows on a seeded book, and every Model & training control calls what it should — and refuses what its disabled button
refused (a reset under a running engine, a fly command to a fly that is not running, a retrain during a run)."""
import json
import uuid
from datetime import datetime, timedelta, timezone

import pytest

from fly_trader import config, markets
from fly_trader.db.connection import transaction
from fly_trader.ui.api import model, trades


# ---------------------------------------------------------------- Trades
@pytest.fixture
def seeded():
    """A Solana book of its own (replay_* books count as Solana's) with closed and open positions, decisions and fills,
    plus one real fill on the RH live book; removed afterwards."""
    book = f"replay_console_{uuid.uuid4().hex[:8]}"
    t0 = datetime(2026, 10, 1, 12, tzinfo=timezone.utc)
    sig_sol, sig_rh = "5" * 88, "0x" + "ab" * 32
    with transaction() as conn:
        pos = [conn.execute("INSERT INTO positions (book, mint, qty, cost_sol, realized_sol, status, opened_at, closed_at, forced_exit_kind, strategy) "
                            "VALUES (%s, %s, 1, %s, %s, %s, %s, %s, %s, %s) RETURNING id",
                            (book, mint, cost, pnl, status, t0 + timedelta(days=i), (t0 + timedelta(days=i, minutes=120)) if status == "closed" else None, kind, strat)).fetchone()["id"]
               for i, (mint, cost, pnl, status, kind, strat) in enumerate([
                   ("MintAAAAAAAA", 1.0, 0.10, "closed", None, "ev"), ("MintBBBBBBBB", 1.0, -0.05, "closed", "stop", "ev"),
                   ("MintCCCCCCCC", 0.5, 0.02, "closed", None, "capitulation"), ("MintDDDDDDDD", 1.0, None, "open", None, "ev")])]
        dec = [conn.execute("INSERT INTO decisions (ts, kind, mint, m_hat, size_sol, rail, reason, book_targets, detail) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING id",
                            (t0 + timedelta(minutes=i), kind, mint, mh, size, rail, reason, targets, json.dumps(detail))).fetchone()["id"]
               for i, (kind, mint, mh, size, rail, reason, targets, detail) in enumerate([
                   ("selector_enter", "MintAAAAAAAA", 0.123, 0.5, None, "cleared the line", None, {"book": book}),
                   ("fly_exit", "MintAAAAAAAA", None, 0.5, None, "held 120 min", [book], {}),
                   ("blocked", "MintBBBBBBBB", 0.2, 0.0, "kill", "switch tripped", None, {"book": book}),
                   ("beat", None, None, None, None, None, None, {"book": book}),                       # not a kind the log shows
                   ("selector_enter", "MintZZZZZZZZ", 0.3, 0.5, None, "another book", None, {"book": book + "_other"})])]
        fil = [conn.execute("INSERT INTO fills (book, ts, side, mint, sol_delta_lamports, price_sol, fee_lamports, verified_by, signature) "
                            "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING id", row).fetchone()["id"]
               for row in [(book, t0, "buy", "MintAAAAAAAA", -500_000_000, 1.5e-7, 5000, "model", None),
                           (book, t0 + timedelta(minutes=1), "sell", "MintAAAAAAAA", 550_000_000, 1.6e-7, 5000, "helius", sig_sol),
                           ("live_rh", t0, "sell", "0xabc", 22_000_000, 1.3e-7, 2000, "receipt", sig_rh)]]
    yield {"book": book, "sig_sol": sig_sol, "sig_rh": sig_rh}
    with transaction() as conn:
        conn.execute("DELETE FROM positions WHERE id = ANY(%s)", (pos,))
        conn.execute("DELETE FROM decisions WHERE id = ANY(%s)", (dec,))
        conn.execute("DELETE FROM fills WHERE id = ANY(%s)", (fil,))


def _get(console, name, **params):
    r = console.topic(name, **params)
    assert r.status_code == 200, r.text
    return r.json()


def test_trades_lists_each_chains_books_and_every_view_reads_them(console, monkeypatch):
    """Port of test_rh_ui: the chain's books come first, in mk.books order, even before their first trade; the selector
    book is the default; every view (closed, decision log, fills) answers for each of them."""
    monkeypatch.setattr(config, "RH_ENABLED", True)
    for m in (markets.SOL, markets.RH):
        b = _get(console, "trades.books", chain=m.chain)
        assert b["books"][:3] == list(m.books) and b["default"] == m.selector_book and b["unit"] == m.unit
        assert b["help"] == f"{m.selector_book} is the selector's paper book, {m.fly_book} the fly's, {m.live_book} the bot wallet; amounts in {m.unit}."
        assert all(markets.for_book(x) is m for x in b["books"])
        for book in m.books:
            for name in ("trades.summary", "trades.closed", "trades.decisions", "trades.fills"):
                d = _get(console, name, chain=m.chain, book=book)
                assert d["book"] == book and d["unit"] == m.unit and isinstance(d["metrics"] if name == "trades.summary" else d["rows"], dict if name == "trades.summary" else list)


def test_a_book_of_another_chain_falls_back_to_the_selector_book(console, monkeypatch):
    monkeypatch.setattr(config, "RH_ENABLED", True)
    assert _get(console, "trades.closed", chain="rh", book="paper_selector")["book"] == "paper_rh_selector"
    assert _get(console, "trades.fills", chain="sol", book="live_rh")["book"] == "paper_selector"
    assert _get(console, "trades.decisions", chain="sol", book=None)["book"] == "paper_selector"
    monkeypatch.setattr(config, "RH_ENABLED", False)                      # RH off: chain=rh is Solana
    d = _get(console, "trades.closed", chain="rh", book="paper_rh_fly")
    assert d["chain"] == "sol" and d["book"] == "paper_selector" and d["unit"] == "SOL"


def test_seen_books_follow_their_chain(console, monkeypatch, seeded):
    monkeypatch.setattr(config, "RH_ENABLED", True)
    sol = _get(console, "trades.books", chain="sol")["books"]
    assert seeded["book"] in sol[3:] and seeded["book"] not in _get(console, "trades.books", chain="rh")["books"]


def test_closed_trades_rows(console, seeded):
    d = _get(console, "trades.closed", chain="sol", book=seeded["book"])
    assert [r["mint"] for r in d["rows"]] == ["MintCCCCCCCC", "MintBBBBBBBB", "MintAAAAAAAA"]       # newest close first; the open one is not a trade yet
    c = d["rows"][0]
    assert c["token"] == "MintCC…" and c["held_min"] == pytest.approx(120) and c["cost"] == 0.5 and c["ret"] == pytest.approx(4.0) and c["exit"] == "time"
    assert c["strategy"] == "capitulation" and d["rows"][1]["exit"] == "stop"


def test_book_summary(console, seeded):
    """The KPI widgets and charts: metrics, open positions, cumulative and daily P&L, trades by strategy and by exit."""
    d = _get(console, "trades.summary", chain="sol", book=seeded["book"])
    m = d["metrics"]
    assert m["n"] == 3 and m["wins"] == 2 and m["win_rate"] == pytest.approx(2 / 3) and m["open"] == 1 and m["open_cost"] == 1.0
    assert m["pnl"] == pytest.approx(0.07) and m["avg_ret"] == pytest.approx((0.10 - 0.05 + 0.04) / 3)
    assert [round(v, 6) for _, v in d["cum"]] == [0.1, 0.05, 0.07]                                    # running total in close order
    assert [(x["day"], x["n"], round(x["pnl"], 6)) for x in d["daily"]] == [("2026-10-01", 1, 0.1), ("2026-10-02", 1, -0.05), ("2026-10-03", 1, 0.02)]
    assert {e["kind"]: e["n"] for e in d["exits"]} == {"time": 2, "stop": 1}
    assert [(x["strategy"], x["n"], x["wins"]) for x in d["strategies"]] == [("ev", 2, 1), ("capitulation", 1, 1)]



def test_an_aborted_position_is_not_a_trade(console, seeded):
    """A failed transaction's gas booked as an aborted zero-quantity position (RH: 48 failed sweeps of one written-off
    token, 2026-11-05..07, read as a 39 % win rate) is no trade: not counted, listed or charted."""
    with transaction() as conn:
        pid = conn.execute("INSERT INTO positions (book, mint, qty, cost_sol, realized_sol, status, opened_at, closed_at, forced_exit_kind) "
                           "VALUES (%s, 'MintABORTED1', 0, 0.00001, -0.00001, 'closed', %s, %s, 'aborted') RETURNING id",
                           (seeded["book"], datetime(2026, 10, 5, tzinfo=timezone.utc), datetime(2026, 10, 5, tzinfo=timezone.utc))).fetchone()["id"]
    try:
        d = _get(console, "trades.summary", chain="sol", book=seeded["book"]); rows = _get(console, "trades.closed", chain="sol", book=seeded["book"])["rows"]
    finally:
        with transaction() as conn:
            conn.execute("DELETE FROM positions WHERE id = %s", (pid,))
    assert d["metrics"]["n"] == 3 and d["metrics"]["win_rate"] == pytest.approx(2 / 3) and "aborted" not in {e["kind"] for e in d["exits"]}
    assert "MintABORTED1" not in [r["mint"] for r in rows] and len(d["cum"]) == 3

def test_summary_of_an_empty_book(console):
    d = _get(console, "trades.summary", chain="sol", book=f"replay_empty_{uuid.uuid4().hex[:6]}")
    assert d["metrics"]["n"] == 0 and d["metrics"]["win_rate"] is None and d["metrics"]["pnl"] is None and d["metrics"]["open"] == 0
    assert d["cum"] == [] and d["daily"] == [] and d["exits"] == [] and d["strategies"] == []
    assert _get(console, "trades.closed", chain="sol", book=d["book"])["rows"] == []


def test_long_series_are_thinned():
    pts = list(range(1000))
    out = trades._thin(pts)
    assert len(out) == 180 and out[0] == 0 and out[-1] == 999 and trades._thin(pts[:50]) == pts[:50]


def test_decision_log_show_pills(console, seeded):
    book = seeded["book"]
    d = _get(console, "trades.decisions", chain="sol", book=book)                           # default: every pill
    assert d["show"] == ["Bought", "Sold", "Not taken"]
    assert [(r["action"], r["mint"]) for r in d["rows"]] == [("Not taken", "MintBBBBBBBB"), ("Sold", "MintAAAAAAAA"), ("Bought", "MintAAAAAAAA")]
    blocked, sold, bought = d["rows"]
    assert blocked["why"] == "kill: switch tripped" and sold["why"] == "held 120 min" and sold["score"] is None    # book_targets counts as this book
    assert bought["score"] == pytest.approx(0.123, rel=1e-4) and bought["size"] == 0.5
    only = _get(console, "trades.decisions", chain="sol", book=book, show=["Not taken"])
    assert [r["kind"] for r in only["rows"]] == ["blocked"]
    assert _get(console, "trades.decisions", chain="sol", book=book, show=["Bought", "Sold"])["show"] == ["Bought", "Sold"]
    assert _get(console, "trades.decisions", chain="sol", book=book, show=[])["rows"] == []
    assert console.topic("trades.decisions", chain="sol", book=book, show="Bought").status_code == 400


def test_fills_mark_simulated_and_link_the_explorer(console, monkeypatch, seeded):
    rows = _get(console, "trades.fills", chain="sol", book=seeded["book"])["rows"]
    real, sim = rows                                                                          # newest first
    assert sim["source"] == "simulated" and sim["url"] is None and sim["amount"] == pytest.approx(-0.5) and sim["fee"] == pytest.approx(5e-6)
    assert real["source"] == "helius" and real["url"] == f"https://solscan.io/tx/{seeded['sig_sol']}" and real["price"] == pytest.approx(1.6e-7)
    monkeypatch.setattr(config, "RH_ENABLED", True)
    rh = [r for r in _get(console, "trades.fills", chain="rh", book="live_rh")["rows"] if r["signature"] == seeded["sig_rh"]]
    assert len(rh) == 1 and rh[0]["url"].endswith(f"/tx/{seeded['sig_rh']}") and "solscan" not in rh[0]["url"]


# ---------------------------------------------------------------- Model & training: actions
@pytest.fixture
def requests(monkeypatch):
    """pipeline.request_run calls, recorded instead of written."""
    from fly_trader.train import pipeline
    calls = []
    monkeypatch.setattr(pipeline, "request_run", lambda fly=False, reason=None: calls.append({"fly": fly, "reason": reason}))
    return calls


def _pipeline_stage(monkeypatch, stage):
    monkeypatch.setattr(model, "_pipeline", lambda: {"stage": stage} if stage else {})


def test_retrain_requests_a_run_and_starts_the_trainer(console, monkeypatch, requests):
    _pipeline_stage(monkeypatch, None)
    r = console.act("model.retrain")
    assert r.status_code == 200 and "started" in r.json()["message"]
    assert requests == [{"fly": False, "reason": None}] and console.sup.calls == [("start", "train", "console")]


def test_retrain_with_the_trainer_running_only_requests(console, monkeypatch, requests):
    _pipeline_stage(monkeypatch, "idle")
    console.sup.alive_set.add("train")
    assert console.act("model.retrain").status_code == 200
    assert requests == [{"fly": False, "reason": None}] and console.sup.calls == []


def test_retrain_refused_during_a_run(console, monkeypatch, requests):
    _pipeline_stage(monkeypatch, "training selector")
    console.sup.alive_set.add("train")
    r = console.act("model.retrain")
    assert r.status_code == 409 and r.json()["error"] == "A training run is already in progress." and requests == []


def test_retrain_shows_a_refused_start(console, monkeypatch, requests):
    _pipeline_stage(monkeypatch, None)

    def refuse(name, started_by="console"):
        raise RuntimeError("train already runs in pid 4242")
    monkeypatch.setattr(console.sup, "start", refuse)
    r = console.act("model.retrain")
    assert r.status_code == 409 and r.json()["error"] == "train already runs in pid 4242"


def test_train_stop(console, monkeypatch):
    _pipeline_stage(monkeypatch, "training selector")
    assert console.act("model.train_stop").status_code == 409                             # the trainer is not alive
    console.sup.alive_set.add("train")
    assert console.act("model.train_stop").status_code == 200 and console.sup.calls == [("request_stop", "train")]
    _pipeline_stage(monkeypatch, "idle")
    assert console.act("model.train_stop").status_code == 409                             # alive but no run: the button is not shown


@pytest.fixture
def sent(monkeypatch):
    from fly_trader.agent import fly_session
    out = []
    monkeypatch.setattr(fly_session, "send_command", out.append)
    return out


def test_fly_commands_go_to_a_running_fly(console, monkeypatch, sent):
    monkeypatch.setattr(model, "_fly_status", lambda: {"stage": "trading"})
    monkeypatch.setattr(model, "runs_elsewhere", lambda name: None)
    r = console.act("model.fly_command", {"cmd": "pause"})                                # a status left by a stopped engine is not a running fly
    assert r.status_code == 409 and "not running" in r.json()["error"] and sent == []
    console.sup.alive_set.add("runner")
    for cmd in ("pause", "resume", "rollback"):
        r = console.act("model.fly_command", {"cmd": cmd})
        assert r.status_code == 200 and r.json()["message"] == "Sent: applied at the next minute"
    assert sent == ["pause", "resume", "rollback"]
    assert console.act("model.fly_command", {"cmd": "explode"}).status_code == 400 and len(sent) == 3


@pytest.mark.parametrize("status", [{}, {"stage": "not trading", "detail": "engine stopped"}])
def test_fly_command_refused_when_the_fly_is_not_running(console, monkeypatch, sent, status):
    monkeypatch.setattr(model, "_fly_status", lambda: status)
    r = console.act("model.fly_command", {"cmd": "pause"})
    assert r.status_code == 409 and "not running" in r.json()["error"] and sent == []


def test_rebootstrap_requests_a_fly_and_starts_the_trainer(console, requests):
    r = console.act("model.fly_rebootstrap")
    assert r.status_code == 200 and r.json()["message"].startswith("Re-bootstrap requested")
    assert requests == [{"fly": True, "reason": "console"}] and console.sup.calls == [("start", "train", "console")]
    console.act("model.fly_rebootstrap")                                                  # now alive: only requests
    assert len(requests) == 2 and console.sup.calls == [("start", "train", "console")]


@pytest.fixture
def resets(monkeypatch):
    from fly_trader.ops import reset
    calls = []
    monkeypatch.setattr(reset, "reset_fly", lambda reason="operator", archive=True: calls.append(reason) or {"archived_to": "/tmp/arch/reset_fly_x", "rows": {"fills": 3}})
    return calls


def test_fly_reset_refused_while_the_engine_runs(console, resets):
    console.sup.alive_set.add("runner")
    r = console.act("model.fly_reset")
    assert r.status_code == 409 and r.json()["error"] == "Stop the trading engine first." and resets == []


def test_fly_reset_archives(console, resets):
    r = console.act("model.fly_reset")
    assert r.status_code == 200 and r.json()["message"] == "Archived to /tmp/arch/reset_fly_x" and r.json()["archived_to"] == "/tmp/arch/reset_fly_x"
    assert resets == ["console button"]


# ---------------------------------------------------------------- Model & training: topics
@pytest.fixture
def selector_at_work():
    """A current, deployable selector snapshot loaded by a running selector session (the newest of both), removed afterwards."""
    from fly_trader.train.selector import DATA_VERSION
    meta = {"data": DATA_VERSION, "first_day": "2026-04-19", "trained_through": "2026-10-02", "threshold": 0.05, "horizon_min": 120, "model": {"min_age_h": 6.0},
            "walk_forward": {"n": 400, "days": 20, "mean": 0.02, "win": 0.55, "pf": 1.4, "days_positive": 14}, "random_baseline": {"mean": -0.03},
            "selection": {"n": 300, "mean": 0.015, "win": 0.5, "pf": 1.2, "weeks": 9, "weeks_pos": 7},
            "holdout": {"n": 90, "mean": 0.01, "random_mean": -0.04, "days": ["2026-09-12", "2026-10-02"], "weeks": 3, "weeks_pos": 2},
            "chains": {"sol": {"n": 50, "mean": 0.012, "random_mean": -0.05}, "zz": {"n": 1}},
            "deployable": True, "deploy_reason": "its backtest made money", "fallback": True,
            "sizing": [{"lo": 0.0, "n": 200, "mean": 0.01, "win": 0.5, "kelly": 0.2}, {"lo": 0.02, "n": 200, "mean": 0.03, "win": 0.6, "kelly": 0.8}],
            "bankroll": {"sized": {"start_sol": 5, "final_sol": 7.5, "max_drawdown": 0.2}, "fixed": {"final_sol": 6.0, "max_drawdown": 0.1}},
            "components": [{"name": "inputs: rug", "passed": True, "reason": "improves ev", "selection": {"win": 0.5, "n": 10}, "evaluation": {"win": 0.6, "pf": None, "total": 2.5, "n": 12},
                            "params": {"groups": ["rug"]}, "trials": 30, "best_seen": {"win": 0.6, "pf": 1.5, "n": 10, "total": 3.0}}],
            "strategies": {"ev": {"line": 0.0115, "hold_min": 120, "thr": {}, "evaluation": {"n": 50, "win": 0.5, "pf": 1.2}}}}
    run_id = str(uuid.uuid4())
    with transaction() as conn:
        sid = conn.execute("INSERT INTO brain_snapshots (path, kind, note) VALUES ('/tmp/sel.pkl', 'selector', %s) RETURNING id", (json.dumps(meta),)).fetchone()["id"]
        conn.execute("INSERT INTO runs (run_id, kind, status, started_at, brain_snapshot_id, config) VALUES (%s, 'selector', 'running', now() + interval '1 day', %s, %s)",
                     (run_id, sid, json.dumps({"threshold": 0.06})))
    yield sid
    with transaction() as conn:
        conn.execute("DELETE FROM runs WHERE run_id = %s", (run_id,))
        conn.execute("DELETE FROM brain_snapshots WHERE id = %s", (sid,))


def test_model_at_work(console, selector_at_work):
    console.sup.alive_set.add("runner")
    d = _get(console, "model.loaded")
    m = d["model"]
    assert m["id"] == selector_at_work and m["current"] and m["threshold"] == 0.06 and m["horizon_min"] == 120 and m["min_age_h"] == 6.0  # the session's line wins
    assert m["wf"]["n"] == 400 and m["random_mean"] == -0.03 and m["backtest_line"].startswith("Backtest on 20 held-out days")
    assert [b["band"] for b in m["sizing"]["bands"]] == ["+0.000 and up", "+0.020 and up"]
    assert m["sizing"]["bands"][1]["bet"] == pytest.approx(min(config.KELLY_FRACTION * 0.8, config.MAX_POSITION_FRACTION) * 100)
    assert "7.50 SOL (worst drawdown 20%)" in m["sizing"]["bankroll"] and m["sizing"]["caption"].startswith("Each buy's size")
    st = m["stack"]
    assert st["fallback"] and st["components"][0]["win_eval"] == pytest.approx(60) and st["components"][0]["pf_eval"] is None
    assert st["components"][0]["best"] == "60% winners · PF 1.50 · 10 trades · total +3.0" and st["strategies"][0]["line"] == pytest.approx(1.15)
    assert [(h["name"], h["random_mean"]) for h in m["halves"]] == [("Selection", None), ("Evaluation", -0.03), ("Holdout", -0.04), ("Holdout · Solana", -0.05)]
    assert m["halves"][2]["days"] == ["2026-09-12", "2026-10-02"] and m["halves"][2]["weeks_pos"] == 2       # a part without a mean (zz) is left out
    assert d["latest"]["id"] >= selector_at_work and "deployable" in d["latest"]
    console.sup.alive_set.discard("runner")
    assert _get(console, "model.loaded")["model"] is None                                 # a stopped engine has no model at work


def test_saved_models_mark_the_one_in_use(console, selector_at_work):
    console.sup.alive_set.add("runner")
    row = next(r for r in _get(console, "model.history")["rows"] if r["id"] == selector_at_work)
    assert row["type"] == "selector" and row["data"] == "current" and row["trades"] == 400 and row["mean"] == pytest.approx(2.0)
    assert row["random"] == pytest.approx(-3.0) and row["pf"] == 1.4 and row["deployed"] is True and row["in_use"] is True


def test_retraining_status(console, monkeypatch):
    from fly_trader.train import pipeline
    vals = {pipeline.KEY: {"stage": "training selector", "last_run_at": "2026-10-01T00:00:00+00:00"},
            "training_status": {"stage": "training selector", "step": 5, "total": 10, "eta_s": 120}, markets.SOL.handover_key: {}}
    monkeypatch.setattr(model, "setting", lambda k: (vals.get(k, {}), None))
    console.sup.alive_set.add("train")
    d = _get(console, "model.retraining")
    assert d["running"] and d["status"] == "Training selector" and d["interval_days"] == pipeline.INTERVAL_DAYS and not d["handover"]
    assert d["progress"] == {"value": 0.5, "text": "training selector · about 2 min left"} and d["next_run"] == "as soon as the data is ready"
    vals[pipeline.KEY] = {"stage": "failed", "last_error": "disk full", "retry_after": None}; vals[markets.SOL.handover_key] = {"at": "x"}
    console.sup.alive_set.clear()
    d = _get(console, "model.retraining")
    assert not d["running"] and d["status"] == "Off" and d["next_run"] == "—" and d["progress"] is None and d["handover"]
    assert d["failed"] == "The last run failed: disk full. Retrying —."
    vals[pipeline.KEY] = {"stage": "waiting for data", "waiting": "3 days not built"}
    assert _get(console, "model.retraining")["waiting"] == "Waiting for the training data: 3 days not built. Checking again —."


def test_backtest_days_and_their_outdated_guard(console, monkeypatch):
    day = f"2099-{uuid.uuid4().int % 12 + 1:02d}-01"
    with transaction() as conn:
        eid = conn.execute("INSERT INTO events (level, source, message, detail) VALUES ('info', 'selector', %s, %s) RETURNING id",
                           (f"walk-forward {day}", json.dumps({"day": day, "half": "evaluation", "ic": 0.05, "n": 40, "mean": 0.012, "random_mean": None, "win": 0.6, "pf": 1.3}))).fetchone()["id"]
    try:
        monkeypatch.setattr(model, "latest_snapshot", lambda kind="selector", deployable=False: {"id": 1, "meta": {}})
        row = next(r for r in _get(console, "model.results")["rows"] if r["day"] == day)
        assert row["model"] == pytest.approx(1.2) and row["random"] is None and row["winners"] == pytest.approx(60) and row["half"] == "evaluation"
        monkeypatch.setattr(model, "latest_snapshot", lambda kind="selector", deployable=False: None)
        assert _get(console, "model.results") == {"hidden": True, "rows": []}
    finally:
        with transaction() as conn:
            conn.execute("DELETE FROM events WHERE id = %s", (eid,))


def test_plastic_fly_panel(console, monkeypatch):
    monkeypatch.setattr(model, "_fly_status", lambda: {"stage": "not trading", "detail": "no deployable bootstrap"})
    d = _get(console, "model.fly")
    assert not d["running"] and d["live"] is None and d["detail"] == "Not trading: no deployable bootstrap." and d["updates"] == []
    monkeypatch.setattr(model, "_fly_status", lambda: {})
    assert _get(console, "model.fly")["detail"] == "Not trading: the trading engine is stopped."
    status = {"stage": "trading", "line": 0.16, "frozen_line": 0.15, "drift": 0.01, "pending": 25, "device": "cpu", "learning_frozen": True,
              "lines": {"ev": 0.16}, "frozen_lines": {"ev": 0.15},
              "checks": {"ev": {"ic": -0.08, "drift": 0.0, "shadow": {"n_frozen": 0, "n_plastic": 0, "mean_frozen": None, "mean_plastic": None}, "triggers": ["ic"]}}}
    monkeypatch.setattr(model, "_fly_status", lambda: status)
    console.sup.alive_set.add("runner")
    d = _get(console, "model.fly")
    assert d["running"] and d["frozen"] and d["runner_alive"] and d["detail"] is None
    assert d["live"]["line"] == 0.16 and d["live"]["ic"] is None and d["live"]["per_strategy"][0] == {
        "strategy": "ev", "ic": -0.08, "drift": 0.0, "mean_plastic": None, "mean_frozen": None, "n_plastic": 0, "n_frozen": 0, "triggers": "ic", "line": 0.16, "frozen_line": 0.15}
    assert d["live"]["drift_max"] == 0.5
    status["checks"] = {"ic": 0.04, "shadow": {"mean_plastic": 0.02, "mean_frozen": 0.01}}            # one strategy: the checks at the top level
    live = _get(console, "model.fly")["live"]
    assert live["ic"] == 0.04 and live["shadow_plastic"] == 0.02 and live["per_strategy"] == []


def test_replay_verdict(console, monkeypatch):
    rp = {"passed": False, "reason": "lost money", "evaluation": {"n": 300, "mean": -0.01, "days_positive": 4, "days": 16}, "random": {"mean": -0.04},
          "frozen": {"mean": -0.02}, "alpha": 0.0001, "half_life_days": 1.0, "S": "2026-09-09", "selection_days": ["2026-09-09", "2026-09-23"], "evaluation_days": []}
    real = model.setting
    monkeypatch.setattr(model, "setting", lambda k: (rp, None) if k == "fly_replay" else real(k))
    monkeypatch.setattr(model, "_fly_status", lambda: {})
    r = _get(console, "model.fly")["replay"]
    assert not r["passed"] and r["reason"] == "lost money" and r["n"] == 300 and r["random_mean"] == -0.04 and r["frozen_mean"] == -0.02
    assert r["alpha"] == "0.0001" and r["half_life"] == "1 days"
    assert r["caption"].endswith("Configuration chosen on 2026-09-09 → 2026-09-23, judged on —.")


def test_trainer_log(console, monkeypatch):
    assert _get(console, "model.trainer_log") == {"text": "(no log yet)"}
    monkeypatch.setattr(console.sup, "log_tail", lambda name, n=60: f"{name} {n} lines")
    assert _get(console, "model.trainer_log") == {"text": "train 40 lines"}